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 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, char *castle, char *ep));
 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 void GameEnds P((ChessMove result, char *resultDetails, int whosays));
 171 void EditPositionDone P((Boolean fakeRights));
 172 void PrintOpponents P((FILE *fp));
 173 void PrintPosition P((FILE *fp, int move));
 174 void StartChessProgram P((ChessProgramState *cps));
 175 void SendToProgram P((char *message, ChessProgramState *cps));
 176 void SendMoveToProgram P((int moveNum, ChessProgramState *cps));
 177 void ReceiveFromProgram P((InputSourceRef isr, VOIDSTAR closure,
 178                            char *buf, int count, int error));
 179 void SendTimeControl P((ChessProgramState *cps,
 180                         int mps, long tc, int inc, int sd, int st));
 181 char *TimeControlTagValue P((void));
 182 void Attention P((ChessProgramState *cps));
 183 void FeedMovesToProgram P((ChessProgramState *cps, int upto));
 184 void ResurrectChessProgram P((void));
 185 void DisplayComment P((int moveNumber, char *text));
 186 void DisplayMove P((int moveNumber));
 187
 188 void ParseGameHistory P((char *game));
 189 void ParseBoard12 P((char *string));
 190 void StartClocks P((void));
 191 void SwitchClocks P((void));
 192 void StopClocks P((void));
 193 void ResetClocks P((void));
 194 char *PGNDate P((void));
 195 void SetGameInfo P((void));
 196 Boolean ParseFEN P((Board board, int *blackPlaysFirst, char *fen));
 197 int RegisterMove P((void));
 198 void MakeRegisteredMove P((void));
 199 void TruncateGame P((void));
 200 int looking_at P((char *, int *, char *));
 201 void CopyPlayerNameIntoFileName P((char **, char *));
 202 char *SavePart P((char *));
 203 int SaveGameOldStyle P((FILE *));
 204 int SaveGamePGN P((FILE *));
 205 void GetTimeMark P((TimeMark *));
 206 long SubtractTimeMarks P((TimeMark *, TimeMark *));
 207 int CheckFlags P((void));
 208 long NextTickLength P((long));
 209 void CheckTimeControl P((void));
 210 void show_bytes P((FILE *, char *, int));
 211 int string_to_rating P((char *str));
 212 void ParseFeatures P((char* args, ChessProgramState *cps));
 213 void InitBackEnd3 P((void));
 214 void FeatureDone P((ChessProgramState* cps, int val));
 215 void InitChessProgram P((ChessProgramState *cps, int setup));
 216 void OutputKibitz(int window, char *text);
 217 int PerpetualChase(int first, int last);
 218 int EngineOutputIsUp();
 219 void InitDrawingSizes(int x, int y);
 220
 221 #ifdef WIN32
 222        extern void ConsoleCreate();
 223 #endif
 224
 225 ChessProgramState *WhitePlayer();
 226 void InsertIntoMemo P((int which, char *text)); // [HGM] kibitz: in engineo.c
 227 int VerifyDisplayMode P(());
 228
 229 char *GetInfoFromComment( int, char * ); // [HGM] PV time: returns stripped comment
 230 void InitEngineUCI( const char * iniDir, ChessProgramState * cps ); // [HGM] moved here from winboard.c
 231 char *ProbeBook P((int moveNr, char *book)); // [HGM] book: returns a book move
 232 char *SendMoveToBookUser P((int nr, ChessProgramState *cps, int initial)); // [HGM] book
 233 void ics_update_width P((int new_width));
 234 extern char installDir[MSG_SIZ];
 235
 236 extern int tinyLayout, smallLayout;
 237 ChessProgramStats programStats;
 238 static int exiting = 0; /* [HGM] moved to top */
 239 static int setboardSpoiledMachineBlack = 0 /*, errorExitFlag = 0*/;
 240 int startedFromPositionFile = FALSE; Board filePosition;       /* [HGM] loadPos */
 241 char endingGame = 0;    /* [HGM] crash: flag to prevent recursion of GameEnds() */
 242 int whiteNPS, blackNPS; /* [HGM] nps: for easily making clocks aware of NPS     */
 243 VariantClass currentlyInitializedVariant; /* [HGM] variantswitch */
 244 int lastIndex = 0;      /* [HGM] autoinc: last game/position used in match mode */
 245 int opponentKibitzes;
 246 int lastSavedGame; /* [HGM] save: ID of game */
 247 char chatPartner[MAX_CHAT][MSG_SIZ]; /* [HGM] chat: list of chatting partners */
 248 extern int chatCount;
 249 int chattingPartner;
 250
 251 /* States for ics_getting_history */
 252 #define H_FALSE 0
 253 #define H_REQUESTED 1
 254 #define H_GOT_REQ_HEADER 2
 255 #define H_GOT_UNREQ_HEADER 3
 256 #define H_GETTING_MOVES 4
 257 #define H_GOT_UNWANTED_HEADER 5
 258
 259 /* whosays values for GameEnds */
 260 #define GE_ICS 0
 261 #define GE_ENGINE 1
 262 #define GE_PLAYER 2
 263 #define GE_FILE 3
 264 #define GE_XBOARD 4
 265 #define GE_ENGINE1 5
 266 #define GE_ENGINE2 6
 267
 268 /* Maximum number of games in a cmail message */
 269 #define CMAIL_MAX_GAMES 20
 270
 271 /* Different types of move when calling RegisterMove */
 272 #define CMAIL_MOVE   0
 273 #define CMAIL_RESIGN 1
 274 #define CMAIL_DRAW   2
 275 #define CMAIL_ACCEPT 3
 276
 277 /* Different types of result to remember for each game */
 278 #define CMAIL_NOT_RESULT 0
 279 #define CMAIL_OLD_RESULT 1
 280 #define CMAIL_NEW_RESULT 2
 281
 282 /* Telnet protocol constants */
 283 #define TN_WILL 0373
 284 #define TN_WONT 0374
 285 #define TN_DO   0375
 286 #define TN_DONT 0376
 287 #define TN_IAC  0377
 288 #define TN_ECHO 0001
 289 #define TN_SGA  0003
 290 #define TN_PORT 23
 291
 292 /* [AS] */
 293 static char * safeStrCpy( char * dst, const char * src, size_t count )
 294 {
 295     assert( dst != NULL );
 296     assert( src != NULL );
 297     assert( count > 0 );
 298
 299     strncpy( dst, src, count );
 300     dst[ count-1 ] = '\0';
 301     return dst;
 302 }
 303
 304 /* Some compiler can't cast u64 to double
 305  * This function do the job for us:
 306
 307  * We use the highest bit for cast, this only
 308  * works if the highest bit is not
 309  * in use (This should not happen)
 310  *
 311  * We used this for all compiler
 312  */
 313 double
 314 u64ToDouble(u64 value)
 315 {
 316   double r;
 317   u64 tmp = value & u64Const(0x7fffffffffffffff);
 318   r = (double)(s64)tmp;
 319   if (value & u64Const(0x8000000000000000))
 320        r +=  9.2233720368547758080e18; /* 2^63 */
 321  return r;
 322 }
 323
 324 /* Fake up flags for now, as we aren't keeping track of castling
 325    availability yet. [HGM] Change of logic: the flag now only
 326    indicates the type of castlings allowed by the rule of the game.
 327    The actual rights themselves are maintained in the array
 328    castlingRights, as part of the game history, and are not probed
 329    by this function.
 330  */
 331 int
 332 PosFlags(index)
 333 {
 334   int flags = F_ALL_CASTLE_OK;
 335   if ((index % 2) == 0) flags |= F_WHITE_ON_MOVE;
 336   switch (gameInfo.variant) {
 337   case VariantSuicide:
 338     flags &= ~F_ALL_CASTLE_OK;
 339   case VariantGiveaway:         // [HGM] moved this case label one down: seems Giveaway does have castling on ICC!
 340     flags |= F_IGNORE_CHECK;
 341   case VariantLosers:
 342     flags |= F_MANDATORY_CAPTURE; //[HGM] losers: sets flag so TestLegality rejects non-capts if capts exist
 343     break;
 344   case VariantAtomic:
 345     flags |= F_IGNORE_CHECK | F_ATOMIC_CAPTURE;
 346     break;
 347   case VariantKriegspiel:
 348     flags |= F_KRIEGSPIEL_CAPTURE;
 349     break;
 350   case VariantCapaRandom:
 351   case VariantFischeRandom:
 352     flags |= F_FRC_TYPE_CASTLING; /* [HGM] enable this through flag */
 353   case VariantNoCastle:
 354   case VariantShatranj:
 355   case VariantCourier:
 356     flags &= ~F_ALL_CASTLE_OK;
 357     break;
 358   default:
 359     break;
 360   }
 361   return flags;
 362 }
 363
 364 FILE *gameFileFP, *debugFP;
 365
 366 /*
 367     [AS] Note: sometimes, the sscanf() function is used to parse the input
 368     into a fixed-size buffer. Because of this, we must be prepared to
 369     receive strings as long as the size of the input buffer, which is currently
 370     set to 4K for Windows and 8K for the rest.
 371     So, we must either allocate sufficiently large buffers here, or
 372     reduce the size of the input buffer in the input reading part.
 373 */
 374
 375 char cmailMove[CMAIL_MAX_GAMES][MOVE_LEN], cmailMsg[MSG_SIZ];
 376 char bookOutput[MSG_SIZ*10], thinkOutput[MSG_SIZ*10], lastHint[MSG_SIZ];
 377 char thinkOutput1[MSG_SIZ*10];
 378
 379 ChessProgramState first, second;
 380
 381 /* premove variables */
 382 int premoveToX = 0;
 383 int premoveToY = 0;
 384 int premoveFromX = 0;
 385 int premoveFromY = 0;
 386 int premovePromoChar = 0;
 387 int gotPremove = 0;
 388 Boolean alarmSounded;
 389 /* end premove variables */
 390
 391 char *ics_prefix = "$";
 392 int ics_type = ICS_GENERIC;
 393
 394 int currentMove = 0, forwardMostMove = 0, backwardMostMove = 0;
 395 int pauseExamForwardMostMove = 0;
 396 int nCmailGames = 0, nCmailResults = 0, nCmailMovesRegistered = 0;
 397 int cmailMoveRegistered[CMAIL_MAX_GAMES], cmailResult[CMAIL_MAX_GAMES];
 398 int cmailMsgLoaded = FALSE, cmailMailedMove = FALSE;
 399 int cmailOldMove = -1, firstMove = TRUE, flipView = FALSE;
 400 int blackPlaysFirst = FALSE, startedFromSetupPosition = FALSE;
 401 int searchTime = 0, pausing = FALSE, pauseExamInvalid = FALSE;
 402 int whiteFlag = FALSE, blackFlag = FALSE;
 403 int userOfferedDraw = FALSE;
 404 int ics_user_moved = 0, ics_gamenum = -1, ics_getting_history = H_FALSE;
 405 int matchMode = FALSE, hintRequested = FALSE, bookRequested = FALSE;
 406 int cmailMoveType[CMAIL_MAX_GAMES];
 407 long ics_clock_paused = 0;
 408 ProcRef icsPR = NoProc, cmailPR = NoProc;
 409 InputSourceRef telnetISR = NULL, fromUserISR = NULL, cmailISR = NULL;
 410 GameMode gameMode = BeginningOfGame;
 411 char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2];
 412 char *commentList[MAX_MOVES], *cmailCommentList[CMAIL_MAX_GAMES];
 413 ChessProgramStats_Move pvInfoList[MAX_MOVES]; /* [AS] Info about engine thinking */
 414 int hiddenThinkOutputState = 0; /* [AS] */
 415 int adjudicateLossThreshold = 0; /* [AS] Automatic adjudication */
 416 int adjudicateLossPlies = 6;
 417 char white_holding[64], black_holding[64];
 418 TimeMark lastNodeCountTime;
 419 long lastNodeCount=0;
 420 int have_sent_ICS_logon = 0;
 421 int movesPerSession;
 422 long whiteTimeRemaining, blackTimeRemaining, timeControl, timeIncrement;
 423 long timeControl_2; /* [AS] Allow separate time controls */
 424 char *fullTimeControlString = NULL; /* [HGM] secondary TC: merge of MPS, TC and inc */
 425 long timeRemaining[2][MAX_MOVES];
 426 int matchGame = 0;
 427 TimeMark programStartTime;
 428 char ics_handle[MSG_SIZ];
 429 int have_set_title = 0;
 430
 431 /* animateTraining preserves the state of appData.animate
 432  * when Training mode is activated. This allows the
 433  * response to be animated when appData.animate == TRUE and
 434  * appData.animateDragging == TRUE.
 435  */
 436 Boolean animateTraining;
 437
 438 GameInfo gameInfo;
 439
 440 AppData appData;
 441
 442 Board boards[MAX_MOVES];
 443 /* [HGM] Following 7 needed for accurate legality tests: */
 444 signed char  epStatus[MAX_MOVES];
 445 signed char  castlingRights[MAX_MOVES][BOARD_SIZE]; // stores files for pieces with castling rights or -1
 446 signed char  castlingRank[BOARD_SIZE]; // and corresponding ranks
 447 signed char  initialRights[BOARD_SIZE], FENcastlingRights[BOARD_SIZE], fileRights[BOARD_SIZE];
 448 int   nrCastlingRights; // For TwoKings, or to implement castling-unknown status
 449 int   initialRulePlies, FENrulePlies;
 450 char  FENepStatus;
 451 FILE  *serverMoves = NULL; // next two for broadcasting (/serverMoves option)
 452 int loadFlag = 0;
 453 int shuffleOpenings;
 454 int mute; // mute all sounds
 455
 456 ChessSquare  FIDEArray[2][BOARD_SIZE] = {
 457     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 458         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 459     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 460         BlackKing, BlackBishop, BlackKnight, BlackRook }
 461 };
 462
 463 ChessSquare twoKingsArray[2][BOARD_SIZE] = {
 464     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 465         WhiteKing, WhiteKing, WhiteKnight, WhiteRook },
 466     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 467         BlackKing, BlackKing, BlackKnight, BlackRook }
 468 };
 469
 470 ChessSquare  KnightmateArray[2][BOARD_SIZE] = {
 471     { WhiteRook, WhiteMan, WhiteBishop, WhiteQueen,
 472         WhiteUnicorn, WhiteBishop, WhiteMan, WhiteRook },
 473     { BlackRook, BlackMan, BlackBishop, BlackQueen,
 474         BlackUnicorn, BlackBishop, BlackMan, BlackRook }
 475 };
 476
 477 ChessSquare fairyArray[2][BOARD_SIZE] = { /* [HGM] Queen side differs from King side */
 478     { WhiteCannon, WhiteNightrider, WhiteAlfil, WhiteQueen,
 479         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 480     { BlackCannon, BlackNightrider, BlackAlfil, BlackQueen,
 481         BlackKing, BlackBishop, BlackKnight, BlackRook }
 482 };
 483
 484 ChessSquare ShatranjArray[2][BOARD_SIZE] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 485     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteKing,
 486         WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 487     { BlackRook, BlackKnight, BlackAlfil, BlackKing,
 488         BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 489 };
 490
 491
 492 #if (BOARD_SIZE>=10)
 493 ChessSquare ShogiArray[2][BOARD_SIZE] = {
 494     { WhiteQueen, WhiteKnight, WhiteFerz, WhiteWazir,
 495         WhiteKing, WhiteWazir, WhiteFerz, WhiteKnight, WhiteQueen },
 496     { BlackQueen, BlackKnight, BlackFerz, BlackWazir,
 497         BlackKing, BlackWazir, BlackFerz, BlackKnight, BlackQueen }
 498 };
 499
 500 ChessSquare XiangqiArray[2][BOARD_SIZE] = {
 501     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteFerz,
 502         WhiteWazir, WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 503     { BlackRook, BlackKnight, BlackAlfil, BlackFerz,
 504         BlackWazir, BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 505 };
 506
 507 ChessSquare CapablancaArray[2][BOARD_SIZE] = {
 508     { WhiteRook, WhiteKnight, WhiteAngel, WhiteBishop, WhiteQueen,
 509         WhiteKing, WhiteBishop, WhiteMarshall, WhiteKnight, WhiteRook },
 510     { BlackRook, BlackKnight, BlackAngel, BlackBishop, BlackQueen,
 511         BlackKing, BlackBishop, BlackMarshall, BlackKnight, BlackRook }
 512 };
 513
 514 ChessSquare GreatArray[2][BOARD_SIZE] = {
 515     { WhiteDragon, WhiteKnight, WhiteAlfil, WhiteGrasshopper, WhiteKing,
 516         WhiteSilver, WhiteCardinal, WhiteAlfil, WhiteKnight, WhiteDragon },
 517     { BlackDragon, BlackKnight, BlackAlfil, BlackGrasshopper, BlackKing,
 518         BlackSilver, BlackCardinal, BlackAlfil, BlackKnight, BlackDragon },
 519 };
 520
 521 ChessSquare JanusArray[2][BOARD_SIZE] = {
 522     { WhiteRook, WhiteAngel, WhiteKnight, WhiteBishop, WhiteKing,
 523         WhiteQueen, WhiteBishop, WhiteKnight, WhiteAngel, WhiteRook },
 524     { BlackRook, BlackAngel, BlackKnight, BlackBishop, BlackKing,
 525         BlackQueen, BlackBishop, BlackKnight, BlackAngel, BlackRook }
 526 };
 527
 528 #ifdef GOTHIC
 529 ChessSquare GothicArray[2][BOARD_SIZE] = {
 530     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen, WhiteMarshall,
 531         WhiteKing, WhiteAngel, WhiteBishop, WhiteKnight, WhiteRook },
 532     { BlackRook, BlackKnight, BlackBishop, BlackQueen, BlackMarshall,
 533         BlackKing, BlackAngel, BlackBishop, BlackKnight, BlackRook }
 534 };
 535 #else // !GOTHIC
 536 #define GothicArray CapablancaArray
 537 #endif // !GOTHIC
 538
 539 #ifdef FALCON
 540 ChessSquare FalconArray[2][BOARD_SIZE] = {
 541     { WhiteRook, WhiteKnight, WhiteBishop, WhiteLance, WhiteQueen,
 542         WhiteKing, WhiteLance, WhiteBishop, WhiteKnight, WhiteRook },
 543     { BlackRook, BlackKnight, BlackBishop, BlackLance, BlackQueen,
 544         BlackKing, BlackLance, BlackBishop, BlackKnight, BlackRook }
 545 };
 546 #else // !FALCON
 547 #define FalconArray CapablancaArray
 548 #endif // !FALCON
 549
 550 #else // !(BOARD_SIZE>=10)
 551 #define XiangqiPosition FIDEArray
 552 #define CapablancaArray FIDEArray
 553 #define GothicArray FIDEArray
 554 #define GreatArray FIDEArray
 555 #endif // !(BOARD_SIZE>=10)
 556
 557 #if (BOARD_SIZE>=12)
 558 ChessSquare CourierArray[2][BOARD_SIZE] = {
 559     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteBishop, WhiteMan, WhiteKing,
 560         WhiteFerz, WhiteWazir, WhiteBishop, WhiteAlfil, WhiteKnight, WhiteRook },
 561     { BlackRook, BlackKnight, BlackAlfil, BlackBishop, BlackMan, BlackKing,
 562         BlackFerz, BlackWazir, BlackBishop, BlackAlfil, BlackKnight, BlackRook }
 563 };
 564 #else // !(BOARD_SIZE>=12)
 565 #define CourierArray CapablancaArray
 566 #endif // !(BOARD_SIZE>=12)
 567
 568
 569 Board initialPosition;
 570
 571
 572 /* Convert str to a rating. Checks for special cases of "----",
 573
 574    "++++", etc. Also strips ()'s */
 575 int
 576 string_to_rating(str)
 577   char *str;
 578 {
 579   while(*str && !isdigit(*str)) ++str;
 580   if (!*str)
 581     return 0;   /* One of the special "no rating" cases */
 582   else
 583     return atoi(str);
 584 }
 585
 586 void
 587 ClearProgramStats()
 588 {
 589     /* Init programStats */
 590     programStats.movelist[0] = 0;
 591     programStats.depth = 0;
 592     programStats.nr_moves = 0;
 593     programStats.moves_left = 0;
 594     programStats.nodes = 0;
 595     programStats.time = -1;        // [HGM] PGNtime: make invalid to recognize engine output
 596     programStats.score = 0;
 597     programStats.got_only_move = 0;
 598     programStats.got_fail = 0;
 599     programStats.line_is_book = 0;
 600 }
 601
 602 void
 603 InitBackEnd1()
 604 {
 605     int matched, min, sec;
 606
 607     ShowThinkingEvent(); // [HGM] thinking: make sure post/nopost state is set according to options
 608
 609     GetTimeMark(&programStartTime);
 610     srandom((programStartTime.ms + 1000*programStartTime.sec)*0x1001001); // [HGM] book: makes sure random is unpredictabe to msec level
 611
 612     ClearProgramStats();
 613     programStats.ok_to_send = 1;
 614     programStats.seen_stat = 0;
 615
 616     /*
 617      * Initialize game list
 618      */
 619     ListNew(&gameList);
 620
 621
 622     /*
 623      * Internet chess server status
 624      */
 625     if (appData.icsActive) {
 626         appData.matchMode = FALSE;
 627         appData.matchGames = 0;
 628 #if ZIPPY
 629         appData.noChessProgram = !appData.zippyPlay;
 630 #else
 631         appData.zippyPlay = FALSE;
 632         appData.zippyTalk = FALSE;
 633         appData.noChessProgram = TRUE;
 634 #endif
 635         if (*appData.icsHelper != NULLCHAR) {
 636             appData.useTelnet = TRUE;
 637             appData.telnetProgram = appData.icsHelper;
 638         }
 639     } else {
 640         appData.zippyTalk = appData.zippyPlay = FALSE;
 641     }
 642
 643     /* [AS] Initialize pv info list [HGM] and game state */
 644     {
 645         int i, j;
 646
 647         for( i=0; i<MAX_MOVES; i++ ) {
 648             pvInfoList[i].depth = -1;
 649             epStatus[i]=EP_NONE;
 650             for( j=0; j<BOARD_SIZE; j++ ) castlingRights[i][j] = -1;
 651         }
 652     }
 653
 654     /*
 655      * Parse timeControl resource
 656      */
 657     if (!ParseTimeControl(appData.timeControl, appData.timeIncrement,
 658                           appData.movesPerSession)) {
 659         char buf[MSG_SIZ];
 660         snprintf(buf, sizeof(buf), _("bad timeControl option %s"), appData.timeControl);
 661         DisplayFatalError(buf, 0, 2);
 662     }
 663
 664     /*
 665      * Parse searchTime resource
 666      */
 667     if (*appData.searchTime != NULLCHAR) {
 668         matched = sscanf(appData.searchTime, "%d:%d", &min, &sec);
 669         if (matched == 1) {
 670             searchTime = min * 60;
 671         } else if (matched == 2) {
 672             searchTime = min * 60 + sec;
 673         } else {
 674             char buf[MSG_SIZ];
 675             snprintf(buf, sizeof(buf), _("bad searchTime option %s"), appData.searchTime);
 676             DisplayFatalError(buf, 0, 2);
 677         }
 678     }
 679
 680     /* [AS] Adjudication threshold */
 681     adjudicateLossThreshold = appData.adjudicateLossThreshold;
 682
 683     first.which = "first";
 684     second.which = "second";
 685     first.maybeThinking = second.maybeThinking = FALSE;
 686     first.pr = second.pr = NoProc;
 687     first.isr = second.isr = NULL;
 688     first.sendTime = second.sendTime = 2;
 689     first.sendDrawOffers = 1;
 690     if (appData.firstPlaysBlack) {
 691         first.twoMachinesColor = "black\n";
 692         second.twoMachinesColor = "white\n";
 693     } else {
 694         first.twoMachinesColor = "white\n";
 695         second.twoMachinesColor = "black\n";
 696     }
 697     first.program = appData.firstChessProgram;
 698     second.program = appData.secondChessProgram;
 699     first.host = appData.firstHost;
 700     second.host = appData.secondHost;
 701     first.dir = appData.firstDirectory;
 702     second.dir = appData.secondDirectory;
 703     first.other = &second;
 704     second.other = &first;
 705     first.initString = appData.initString;
 706     second.initString = appData.secondInitString;
 707     first.computerString = appData.firstComputerString;
 708     second.computerString = appData.secondComputerString;
 709     first.useSigint = second.useSigint = TRUE;
 710     first.useSigterm = second.useSigterm = TRUE;
 711     first.reuse = appData.reuseFirst;
 712     second.reuse = appData.reuseSecond;
 713     first.nps = appData.firstNPS;   // [HGM] nps: copy nodes per second
 714     second.nps = appData.secondNPS;
 715     first.useSetboard = second.useSetboard = FALSE;
 716     first.useSAN = second.useSAN = FALSE;
 717     first.usePing = second.usePing = FALSE;
 718     first.lastPing = second.lastPing = 0;
 719     first.lastPong = second.lastPong = 0;
 720     first.usePlayother = second.usePlayother = FALSE;
 721     first.useColors = second.useColors = TRUE;
 722     first.useUsermove = second.useUsermove = FALSE;
 723     first.sendICS = second.sendICS = FALSE;
 724     first.sendName = second.sendName = appData.icsActive;
 725     first.sdKludge = second.sdKludge = FALSE;
 726     first.stKludge = second.stKludge = FALSE;
 727     TidyProgramName(first.program, first.host, first.tidy);
 728     TidyProgramName(second.program, second.host, second.tidy);
 729     first.matchWins = second.matchWins = 0;
 730     strcpy(first.variants, appData.variant);
 731     strcpy(second.variants, appData.variant);
 732     first.analysisSupport = second.analysisSupport = 2; /* detect */
 733     first.analyzing = second.analyzing = FALSE;
 734     first.initDone = second.initDone = FALSE;
 735
 736     /* New features added by Tord: */
 737     first.useFEN960 = FALSE; second.useFEN960 = FALSE;
 738     first.useOOCastle = TRUE; second.useOOCastle = TRUE;
 739     /* End of new features added by Tord. */
 740     first.fenOverride  = appData.fenOverride1;
 741     second.fenOverride = appData.fenOverride2;
 742
 743     /* [HGM] time odds: set factor for each machine */
 744     first.timeOdds  = appData.firstTimeOdds;
 745     second.timeOdds = appData.secondTimeOdds;
 746     { int norm = 1;
 747         if(appData.timeOddsMode) {
 748             norm = first.timeOdds;
 749             if(norm > second.timeOdds) norm = second.timeOdds;
 750         }
 751         first.timeOdds /= norm;
 752         second.timeOdds /= norm;
 753     }
 754
 755     /* [HGM] secondary TC: how to handle sessions that do not fit in 'level'*/
 756     first.accumulateTC = appData.firstAccumulateTC;
 757     second.accumulateTC = appData.secondAccumulateTC;
 758     first.maxNrOfSessions = second.maxNrOfSessions = 1;
 759
 760     /* [HGM] debug */
 761     first.debug = second.debug = FALSE;
 762     first.supportsNPS = second.supportsNPS = UNKNOWN;
 763
 764     /* [HGM] options */
 765     first.optionSettings  = appData.firstOptions;
 766     second.optionSettings = appData.secondOptions;
 767
 768     first.scoreIsAbsolute = appData.firstScoreIsAbsolute; /* [AS] */
 769     second.scoreIsAbsolute = appData.secondScoreIsAbsolute; /* [AS] */
 770     first.isUCI = appData.firstIsUCI; /* [AS] */
 771     second.isUCI = appData.secondIsUCI; /* [AS] */
 772     first.hasOwnBookUCI = appData.firstHasOwnBookUCI; /* [AS] */
 773     second.hasOwnBookUCI = appData.secondHasOwnBookUCI; /* [AS] */
 774
 775     if (appData.firstProtocolVersion > PROTOVER ||
 776         appData.firstProtocolVersion < 1) {
 777       char buf[MSG_SIZ];
 778       sprintf(buf, _("protocol version %d not supported"),
 779               appData.firstProtocolVersion);
 780       DisplayFatalError(buf, 0, 2);
 781     } else {
 782       first.protocolVersion = appData.firstProtocolVersion;
 783     }
 784
 785     if (appData.secondProtocolVersion > PROTOVER ||
 786         appData.secondProtocolVersion < 1) {
 787       char buf[MSG_SIZ];
 788       sprintf(buf, _("protocol version %d not supported"),
 789               appData.secondProtocolVersion);
 790       DisplayFatalError(buf, 0, 2);
 791     } else {
 792       second.protocolVersion = appData.secondProtocolVersion;
 793     }
 794
 795     if (appData.icsActive) {
 796         appData.clockMode = TRUE;  /* changes dynamically in ICS mode */
 797     } else if (*appData.searchTime != NULLCHAR || appData.noChessProgram) {
 798         appData.clockMode = FALSE;
 799         first.sendTime = second.sendTime = 0;
 800     }
 801
 802 #if ZIPPY
 803     /* Override some settings from environment variables, for backward
 804        compatibility.  Unfortunately it's not feasible to have the env
 805        vars just set defaults, at least in xboard.  Ugh.
 806     */
 807     if (appData.icsActive && (appData.zippyPlay || appData.zippyTalk)) {
 808       ZippyInit();
 809     }
 810 #endif
 811
 812     if (appData.noChessProgram) {
 813         programVersion = (char*) malloc(5 + strlen(PACKAGE_STRING));
 814         sprintf(programVersion, "%s", PACKAGE_STRING);
 815     } else {
 816       /* [HGM] tidy: use tidy name, in stead of full pathname (which was probably a bug due to / vs \ ) */
 817       programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
 818       sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
 819     }
 820
 821     if (!appData.icsActive) {
 822       char buf[MSG_SIZ];
 823       /* Check for variants that are supported only in ICS mode,
 824          or not at all.  Some that are accepted here nevertheless
 825          have bugs; see comments below.
 826       */
 827       VariantClass variant = StringToVariant(appData.variant);
 828       switch (variant) {
 829       case VariantBughouse:     /* need four players and two boards */
 830       case VariantKriegspiel:   /* need to hide pieces and move details */
 831       /* case VariantFischeRandom: (Fabien: moved below) */
 832         sprintf(buf, _("Variant %s supported only in ICS mode"), appData.variant);
 833         DisplayFatalError(buf, 0, 2);
 834         return;
 835
 836       case VariantUnknown:
 837       case VariantLoadable:
 838       case Variant29:
 839       case Variant30:
 840       case Variant31:
 841       case Variant32:
 842       case Variant33:
 843       case Variant34:
 844       case Variant35:
 845       case Variant36:
 846       default:
 847         sprintf(buf, _("Unknown variant name %s"), appData.variant);
 848         DisplayFatalError(buf, 0, 2);
 849         return;
 850
 851       case VariantXiangqi:    /* [HGM] repetition rules not implemented */
 852       case VariantFairy:      /* [HGM] TestLegality definitely off! */
 853       case VariantGothic:     /* [HGM] should work */
 854       case VariantCapablanca: /* [HGM] should work */
 855       case VariantCourier:    /* [HGM] initial forced moves not implemented */
 856       case VariantShogi:      /* [HGM] drops not tested for legality */
 857       case VariantKnightmate: /* [HGM] should work */
 858       case VariantCylinder:   /* [HGM] untested */
 859       case VariantFalcon:     /* [HGM] untested */
 860       case VariantCrazyhouse: /* holdings not shown, ([HGM] fixed that!)
 861                                  offboard interposition not understood */
 862       case VariantNormal:     /* definitely works! */
 863       case VariantWildCastle: /* pieces not automatically shuffled */
 864       case VariantNoCastle:   /* pieces not automatically shuffled */
 865       case VariantFischeRandom: /* [HGM] works and shuffles pieces */
 866       case VariantLosers:     /* should work except for win condition,
 867                                  and doesn't know captures are mandatory */
 868       case VariantSuicide:    /* should work except for win condition,
 869                                  and doesn't know captures are mandatory */
 870       case VariantGiveaway:   /* should work except for win condition,
 871                                  and doesn't know captures are mandatory */
 872       case VariantTwoKings:   /* should work */
 873       case VariantAtomic:     /* should work except for win condition */
 874       case Variant3Check:     /* should work except for win condition */
 875       case VariantShatranj:   /* should work except for all win conditions */
 876       case VariantBerolina:   /* might work if TestLegality is off */
 877       case VariantCapaRandom: /* should work */
 878       case VariantJanus:      /* should work */
 879       case VariantSuper:      /* experimental */
 880       case VariantGreat:      /* experimental, requires legality testing to be off */
 881         break;
 882       }
 883     }
 884
 885     InitEngineUCI( installDir, &first );  // [HGM] moved here from winboard.c, to make available in xboard
 886     InitEngineUCI( installDir, &second );
 887 }
 888
 889 int NextIntegerFromString( char ** str, long * value )
 890 {
 891     int result = -1;
 892     char * s = *str;
 893
 894     while( *s == ' ' || *s == '\t' ) {
 895         s++;
 896     }
 897
 898     *value = 0;
 899
 900     if( *s >= '0' && *s <= '9' ) {
 901         while( *s >= '0' && *s <= '9' ) {
 902             *value = *value * 10 + (*s - '0');
 903             s++;
 904         }
 905
 906         result = 0;
 907     }
 908
 909     *str = s;
 910
 911     return result;
 912 }
 913
 914 int NextTimeControlFromString( char ** str, long * value )
 915 {
 916     long temp;
 917     int result = NextIntegerFromString( str, &temp );
 918
 919     if( result == 0 ) {
 920         *value = temp * 60; /* Minutes */
 921         if( **str == ':' ) {
 922             (*str)++;
 923             result = NextIntegerFromString( str, &temp );
 924             *value += temp; /* Seconds */
 925         }
 926     }
 927
 928     return result;
 929 }
 930
 931 int NextSessionFromString( char ** str, int *moves, long * tc, long *inc)
 932 {   /* [HGM] routine added to read '+moves/time' for secondary time control */
 933     int result = -1; long temp, temp2;
 934
 935     if(**str != '+') return -1; // old params remain in force!
 936     (*str)++;
 937     if( NextTimeControlFromString( str, &temp ) ) return -1;
 938
 939     if(**str != '/') {
 940         /* time only: incremental or sudden-death time control */
 941         if(**str == '+') { /* increment follows; read it */
 942             (*str)++;
 943             if(result = NextIntegerFromString( str, &temp2)) return -1;
 944             *inc = temp2 * 1000;
 945         } else *inc = 0;
 946         *moves = 0; *tc = temp * 1000;
 947         return 0;
 948     } else if(temp % 60 != 0) return -1;     /* moves was given as min:sec */
 949
 950     (*str)++; /* classical time control */
 951     result = NextTimeControlFromString( str, &temp2);
 952     if(result == 0) {
 953         *moves = temp/60;
 954         *tc    = temp2 * 1000;
 955         *inc   = 0;
 956     }
 957     return result;
 958 }
 959
 960 int GetTimeQuota(int movenr)
 961 {   /* [HGM] get time to add from the multi-session time-control string */
 962     int moves=1; /* kludge to force reading of first session */
 963     long time, increment;
 964     char *s = fullTimeControlString;
 965
 966     if(appData.debugMode) fprintf(debugFP, "TC string = '%s'\n", fullTimeControlString);
 967     do {
 968         if(moves) NextSessionFromString(&s, &moves, &time, &increment);
 969         if(appData.debugMode) fprintf(debugFP, "mps=%d tc=%d inc=%d\n", moves, (int) time, (int) increment);
 970         if(movenr == -1) return time;    /* last move before new session     */
 971         if(!moves) return increment;     /* current session is incremental   */
 972         if(movenr >= 0) movenr -= moves; /* we already finished this session */
 973     } while(movenr >= -1);               /* try again for next session       */
 974
 975     return 0; // no new time quota on this move
 976 }
 977
 978 int
 979 ParseTimeControl(tc, ti, mps)
 980      char *tc;
 981      int ti;
 982      int mps;
 983 {
 984   long tc1;
 985   long tc2;
 986   char buf[MSG_SIZ];
 987
 988   if(ti >= 0 && !strchr(tc, '+') && !strchr(tc, '/') ) mps = 0;
 989   if(ti > 0) {
 990     if(mps)
 991       sprintf(buf, "+%d/%s+%d", mps, tc, ti);
 992     else sprintf(buf, "+%s+%d", tc, ti);
 993   } else {
 994     if(mps)
 995              sprintf(buf, "+%d/%s", mps, tc);
 996     else sprintf(buf, "+%s", tc);
 997   }
 998   fullTimeControlString = StrSave(buf);
 999
1000   if( NextTimeControlFromString( &tc, &tc1 ) != 0 ) {
1001     return FALSE;
1002   }
1003
1004   if( *tc == '/' ) {
1005     /* Parse second time control */
1006     tc++;
1007
1008     if( NextTimeControlFromString( &tc, &tc2 ) != 0 ) {
1009       return FALSE;
1010     }
1011
1012     if( tc2 == 0 ) {
1013       return FALSE;
1014     }
1015
1016     timeControl_2 = tc2 * 1000;
1017   }
1018   else {
1019     timeControl_2 = 0;
1020   }
1021
1022   if( tc1 == 0 ) {
1023     return FALSE;
1024   }
1025
1026   timeControl = tc1 * 1000;
1027
1028   if (ti >= 0) {
1029     timeIncrement = ti * 1000;  /* convert to ms */
1030     movesPerSession = 0;
1031   } else {
1032     timeIncrement = 0;
1033     movesPerSession = mps;
1034   }
1035   return TRUE;
1036 }
1037
1038 void
1039 InitBackEnd2()
1040 {
1041     if (appData.debugMode) {
1042         fprintf(debugFP, "%s\n", programVersion);
1043     }
1044
1045     set_cont_sequence(appData.wrapContSeq);
1046     if (appData.matchGames > 0) {
1047         appData.matchMode = TRUE;
1048     } else if (appData.matchMode) {
1049         appData.matchGames = 1;
1050     }
1051     if(appData.matchMode && appData.sameColorGames > 0) /* [HGM] alternate: overrule matchGames */
1052         appData.matchGames = appData.sameColorGames;
1053     if(appData.rewindIndex > 1) { /* [HGM] autoinc: rewind implies auto-increment and overrules given index */
1054         if(appData.loadPositionIndex >= 0) appData.loadPositionIndex = -1;
1055         if(appData.loadGameIndex >= 0) appData.loadGameIndex = -1;
1056     }
1057     Reset(TRUE, FALSE);
1058     if (appData.noChessProgram || first.protocolVersion == 1) {
1059       InitBackEnd3();
1060     } else {
1061       /* kludge: allow timeout for initial "feature" commands */
1062       FreezeUI();
1063       DisplayMessage("", _("Starting chess program"));
1064       ScheduleDelayedEvent(InitBackEnd3, FEATURE_TIMEOUT);
1065     }
1066 }
1067
1068 void
1069 InitBackEnd3 P((void))
1070 {
1071     GameMode initialMode;
1072     char buf[MSG_SIZ];
1073     int err;
1074
1075     InitChessProgram(&first, startedFromSetupPosition);
1076
1077
1078     if (appData.icsActive) {
1079 #ifdef WIN32
1080         /* [DM] Make a console window if needed [HGM] merged ifs */
1081         ConsoleCreate();
1082 #endif
1083         err = establish();
1084         if (err != 0) {
1085             if (*appData.icsCommPort != NULLCHAR) {
1086                 sprintf(buf, _("Could not open comm port %s"),
1087                         appData.icsCommPort);
1088             } else {
1089                 snprintf(buf, sizeof(buf), _("Could not connect to host %s, port %s"),
1090                         appData.icsHost, appData.icsPort);
1091             }
1092             DisplayFatalError(buf, err, 1);
1093             return;
1094         }
1095         SetICSMode();
1096         telnetISR =
1097           AddInputSource(icsPR, FALSE, read_from_ics, &telnetISR);
1098         fromUserISR =
1099           AddInputSource(NoProc, FALSE, read_from_player, &fromUserISR);
1100     } else if (appData.noChessProgram) {
1101         SetNCPMode();
1102     } else {
1103         SetGNUMode();
1104     }
1105
1106     if (*appData.cmailGameName != NULLCHAR) {
1107         SetCmailMode();
1108         OpenLoopback(&cmailPR);
1109         cmailISR =
1110           AddInputSource(cmailPR, FALSE, CmailSigHandlerCallBack, &cmailISR);
1111     }
1112
1113     ThawUI();
1114     DisplayMessage("", "");
1115     if (StrCaseCmp(appData.initialMode, "") == 0) {
1116       initialMode = BeginningOfGame;
1117     } else if (StrCaseCmp(appData.initialMode, "TwoMachines") == 0) {
1118       initialMode = TwoMachinesPlay;
1119     } else if (StrCaseCmp(appData.initialMode, "AnalyzeFile") == 0) {
1120       initialMode = AnalyzeFile;
1121     } else if (StrCaseCmp(appData.initialMode, "Analysis") == 0) {
1122       initialMode = AnalyzeMode;
1123     } else if (StrCaseCmp(appData.initialMode, "MachineWhite") == 0) {
1124       initialMode = MachinePlaysWhite;
1125     } else if (StrCaseCmp(appData.initialMode, "MachineBlack") == 0) {
1126       initialMode = MachinePlaysBlack;
1127     } else if (StrCaseCmp(appData.initialMode, "EditGame") == 0) {
1128       initialMode = EditGame;
1129     } else if (StrCaseCmp(appData.initialMode, "EditPosition") == 0) {
1130       initialMode = EditPosition;
1131     } else if (StrCaseCmp(appData.initialMode, "Training") == 0) {
1132       initialMode = Training;
1133     } else {
1134       sprintf(buf, _("Unknown initialMode %s"), appData.initialMode);
1135       DisplayFatalError(buf, 0, 2);
1136       return;
1137     }
1138
1139     if (appData.matchMode) {
1140         /* Set up machine vs. machine match */
1141         if (appData.noChessProgram) {
1142             DisplayFatalError(_("Can't have a match with no chess programs"),
1143                               0, 2);
1144             return;
1145         }
1146         matchMode = TRUE;
1147         matchGame = 1;
1148         if (*appData.loadGameFile != NULLCHAR) {
1149             int index = appData.loadGameIndex; // [HGM] autoinc
1150             if(index<0) lastIndex = index = 1;
1151             if (!LoadGameFromFile(appData.loadGameFile,
1152                                   index,
1153                                   appData.loadGameFile, FALSE)) {
1154                 DisplayFatalError(_("Bad game file"), 0, 1);
1155                 return;
1156             }
1157         } else if (*appData.loadPositionFile != NULLCHAR) {
1158             int index = appData.loadPositionIndex; // [HGM] autoinc
1159             if(index<0) lastIndex = index = 1;
1160             if (!LoadPositionFromFile(appData.loadPositionFile,
1161                                       index,
1162                                       appData.loadPositionFile)) {
1163                 DisplayFatalError(_("Bad position file"), 0, 1);
1164                 return;
1165             }
1166         }
1167         TwoMachinesEvent();
1168     } else if (*appData.cmailGameName != NULLCHAR) {
1169         /* Set up cmail mode */
1170         ReloadCmailMsgEvent(TRUE);
1171     } else {
1172         /* Set up other modes */
1173         if (initialMode == AnalyzeFile) {
1174           if (*appData.loadGameFile == NULLCHAR) {
1175             DisplayFatalError(_("AnalyzeFile mode requires a game file"), 0, 1);
1176             return;
1177           }
1178         }
1179         if (*appData.loadGameFile != NULLCHAR) {
1180             (void) LoadGameFromFile(appData.loadGameFile,
1181                                     appData.loadGameIndex,
1182                                     appData.loadGameFile, TRUE);
1183         } else if (*appData.loadPositionFile != NULLCHAR) {
1184             (void) LoadPositionFromFile(appData.loadPositionFile,
1185                                         appData.loadPositionIndex,
1186                                         appData.loadPositionFile);
1187             /* [HGM] try to make self-starting even after FEN load */
1188             /* to allow automatic setup of fairy variants with wtm */
1189             if(initialMode == BeginningOfGame && !blackPlaysFirst) {
1190                 gameMode = BeginningOfGame;
1191                 setboardSpoiledMachineBlack = 1;
1192             }
1193             /* [HGM] loadPos: make that every new game uses the setup */
1194             /* from file as long as we do not switch variant          */
1195             if(!blackPlaysFirst) { int i;
1196                 startedFromPositionFile = TRUE;
1197                 CopyBoard(filePosition, boards[0]);
1198                 for(i=0; i<BOARD_SIZE; i++) fileRights[i] = castlingRights[0][i];
1199             }
1200         }
1201         if (initialMode == AnalyzeMode) {
1202           if (appData.noChessProgram) {
1203             DisplayFatalError(_("Analysis mode requires a chess engine"), 0, 2);
1204             return;
1205           }
1206           if (appData.icsActive) {
1207             DisplayFatalError(_("Analysis mode does not work with ICS mode"),0,2);
1208             return;
1209           }
1210           AnalyzeModeEvent();
1211         } else if (initialMode == AnalyzeFile) {
1212           appData.showThinking = TRUE; // [HGM] thinking: moved out of ShowThinkingEvent
1213           ShowThinkingEvent();
1214           AnalyzeFileEvent();
1215           AnalysisPeriodicEvent(1);
1216         } else if (initialMode == MachinePlaysWhite) {
1217           if (appData.noChessProgram) {
1218             DisplayFatalError(_("MachineWhite mode requires a chess engine"),
1219                               0, 2);
1220             return;
1221           }
1222           if (appData.icsActive) {
1223             DisplayFatalError(_("MachineWhite mode does not work with ICS mode"),
1224                               0, 2);
1225             return;
1226           }
1227           MachineWhiteEvent();
1228         } else if (initialMode == MachinePlaysBlack) {
1229           if (appData.noChessProgram) {
1230             DisplayFatalError(_("MachineBlack mode requires a chess engine"),
1231                               0, 2);
1232             return;
1233           }
1234           if (appData.icsActive) {
1235             DisplayFatalError(_("MachineBlack mode does not work with ICS mode"),
1236                               0, 2);
1237             return;
1238           }
1239           MachineBlackEvent();
1240         } else if (initialMode == TwoMachinesPlay) {
1241           if (appData.noChessProgram) {
1242             DisplayFatalError(_("TwoMachines mode requires a chess engine"),
1243                               0, 2);
1244             return;
1245           }
1246           if (appData.icsActive) {
1247             DisplayFatalError(_("TwoMachines mode does not work with ICS mode"),
1248                               0, 2);
1249             return;
1250           }
1251           TwoMachinesEvent();
1252         } else if (initialMode == EditGame) {
1253           EditGameEvent();
1254         } else if (initialMode == EditPosition) {
1255           EditPositionEvent();
1256         } else if (initialMode == Training) {
1257           if (*appData.loadGameFile == NULLCHAR) {
1258             DisplayFatalError(_("Training mode requires a game file"), 0, 2);
1259             return;
1260           }
1261           TrainingEvent();
1262         }
1263     }
1264 }
1265
1266 /*
1267  * Establish will establish a contact to a remote host.port.
1268  * Sets icsPR to a ProcRef for a process (or pseudo-process)
1269  *  used to talk to the host.
1270  * Returns 0 if okay, error code if not.
1271  */
1272 int
1273 establish()
1274 {
1275     char buf[MSG_SIZ];
1276
1277     if (*appData.icsCommPort != NULLCHAR) {
1278         /* Talk to the host through a serial comm port */
1279         return OpenCommPort(appData.icsCommPort, &icsPR);
1280
1281     } else if (*appData.gateway != NULLCHAR) {
1282         if (*appData.remoteShell == NULLCHAR) {
1283             /* Use the rcmd protocol to run telnet program on a gateway host */
1284             snprintf(buf, sizeof(buf), "%s %s %s",
1285                     appData.telnetProgram, appData.icsHost, appData.icsPort);
1286             return OpenRcmd(appData.gateway, appData.remoteUser, buf, &icsPR);
1287
1288         } else {
1289             /* Use the rsh program to run telnet program on a gateway host */
1290             if (*appData.remoteUser == NULLCHAR) {
1291                 snprintf(buf, sizeof(buf), "%s %s %s %s %s", appData.remoteShell,
1292                         appData.gateway, appData.telnetProgram,
1293                         appData.icsHost, appData.icsPort);
1294             } else {
1295                 snprintf(buf, sizeof(buf), "%s %s -l %s %s %s %s",
1296                         appData.remoteShell, appData.gateway,
1297                         appData.remoteUser, appData.telnetProgram,
1298                         appData.icsHost, appData.icsPort);
1299             }
1300             return StartChildProcess(buf, "", &icsPR);
1301
1302         }
1303     } else if (appData.useTelnet) {
1304         return OpenTelnet(appData.icsHost, appData.icsPort, &icsPR);
1305
1306     } else {
1307         /* TCP socket interface differs somewhat between
1308            Unix and NT; handle details in the front end.
1309            */
1310         return OpenTCP(appData.icsHost, appData.icsPort, &icsPR);
1311     }
1312 }
1313
1314 void
1315 show_bytes(fp, buf, count)
1316      FILE *fp;
1317      char *buf;
1318      int count;
1319 {
1320     while (count--) {
1321         if (*buf < 040 || *(unsigned char *) buf > 0177) {
1322             fprintf(fp, "\\%03o", *buf & 0xff);
1323         } else {
1324             putc(*buf, fp);
1325         }
1326         buf++;
1327     }
1328     fflush(fp);
1329 }
1330
1331 /* Returns an errno value */
1332 int
1333 OutputMaybeTelnet(pr, message, count, outError)
1334      ProcRef pr;
1335      char *message;
1336      int count;
1337      int *outError;
1338 {
1339     char buf[8192], *p, *q, *buflim;
1340     int left, newcount, outcount;
1341
1342     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet ||
1343         *appData.gateway != NULLCHAR) {
1344         if (appData.debugMode) {
1345             fprintf(debugFP, ">ICS: ");
1346             show_bytes(debugFP, message, count);
1347             fprintf(debugFP, "\n");
1348         }
1349         return OutputToProcess(pr, message, count, outError);
1350     }
1351
1352     buflim = &buf[sizeof(buf)-1]; /* allow 1 byte for expanding last char */
1353     p = message;
1354     q = buf;
1355     left = count;
1356     newcount = 0;
1357     while (left) {
1358         if (q >= buflim) {
1359             if (appData.debugMode) {
1360                 fprintf(debugFP, ">ICS: ");
1361                 show_bytes(debugFP, buf, newcount);
1362                 fprintf(debugFP, "\n");
1363             }
1364             outcount = OutputToProcess(pr, buf, newcount, outError);
1365             if (outcount < newcount) return -1; /* to be sure */
1366             q = buf;
1367             newcount = 0;
1368         }
1369         if (*p == '\n') {
1370             *q++ = '\r';
1371             newcount++;
1372         } else if (((unsigned char) *p) == TN_IAC) {
1373             *q++ = (char) TN_IAC;
1374             newcount ++;
1375         }
1376         *q++ = *p++;
1377         newcount++;
1378         left--;
1379     }
1380     if (appData.debugMode) {
1381         fprintf(debugFP, ">ICS: ");
1382         show_bytes(debugFP, buf, newcount);
1383         fprintf(debugFP, "\n");
1384     }
1385     outcount = OutputToProcess(pr, buf, newcount, outError);
1386     if (outcount < newcount) return -1; /* to be sure */
1387     return count;
1388 }
1389
1390 void
1391 read_from_player(isr, closure, message, count, error)
1392      InputSourceRef isr;
1393      VOIDSTAR closure;
1394      char *message;
1395      int count;
1396      int error;
1397 {
1398     int outError, outCount;
1399     static int gotEof = 0;
1400
1401     /* Pass data read from player on to ICS */
1402     if (count > 0) {
1403         gotEof = 0;
1404         outCount = OutputMaybeTelnet(icsPR, message, count, &outError);
1405         if (outCount < count) {
1406             DisplayFatalError(_("Error writing to ICS"), outError, 1);
1407         }
1408     } else if (count < 0) {
1409         RemoveInputSource(isr);
1410         DisplayFatalError(_("Error reading from keyboard"), error, 1);
1411     } else if (gotEof++ > 0) {
1412         RemoveInputSource(isr);
1413         DisplayFatalError(_("Got end of file from keyboard"), 0, 0);
1414     }
1415 }
1416
1417 void
1418 KeepAlive()
1419 {   // [HGM] alive: periodically send dummy (date) command to ICS to prevent time-out
1420     SendToICS("date\n");
1421     if(appData.keepAlive) ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1422 }
1423
1424 /* added routine for printf style output to ics */
1425 void ics_printf(char *format, ...)
1426 {
1427     char buffer[MSG_SIZ];
1428     va_list args;
1429
1430     va_start(args, format);
1431     vsnprintf(buffer, sizeof(buffer), format, args);
1432     buffer[sizeof(buffer)-1] = '\0';
1433     SendToICS(buffer);
1434     va_end(args);
1435 }
1436
1437 void
1438 SendToICS(s)
1439      char *s;
1440 {
1441     int count, outCount, outError;
1442
1443     if (icsPR == NULL) return;
1444
1445     count = strlen(s);
1446     outCount = OutputMaybeTelnet(icsPR, s, count, &outError);
1447     if (outCount < count) {
1448         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1449     }
1450 }
1451
1452 /* This is used for sending logon scripts to the ICS. Sending
1453    without a delay causes problems when using timestamp on ICC
1454    (at least on my machine). */
1455 void
1456 SendToICSDelayed(s,msdelay)
1457      char *s;
1458      long msdelay;
1459 {
1460     int count, outCount, outError;
1461
1462     if (icsPR == NULL) return;
1463
1464     count = strlen(s);
1465     if (appData.debugMode) {
1466         fprintf(debugFP, ">ICS: ");
1467         show_bytes(debugFP, s, count);
1468         fprintf(debugFP, "\n");
1469     }
1470     outCount = OutputToProcessDelayed(icsPR, s, count, &outError,
1471                                       msdelay);
1472     if (outCount < count) {
1473         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1474     }
1475 }
1476
1477
1478 /* Remove all highlighting escape sequences in s
1479    Also deletes any suffix starting with '('
1480    */
1481 char *
1482 StripHighlightAndTitle(s)
1483      char *s;
1484 {
1485     static char retbuf[MSG_SIZ];
1486     char *p = retbuf;
1487
1488     while (*s != NULLCHAR) {
1489         while (*s == '\033') {
1490             while (*s != NULLCHAR && !isalpha(*s)) s++;
1491             if (*s != NULLCHAR) s++;
1492         }
1493         while (*s != NULLCHAR && *s != '\033') {
1494             if (*s == '(' || *s == '[') {
1495                 *p = NULLCHAR;
1496                 return retbuf;
1497             }
1498             *p++ = *s++;
1499         }
1500     }
1501     *p = NULLCHAR;
1502     return retbuf;
1503 }
1504
1505 /* Remove all highlighting escape sequences in s */
1506 char *
1507 StripHighlight(s)
1508      char *s;
1509 {
1510     static char retbuf[MSG_SIZ];
1511     char *p = retbuf;
1512
1513     while (*s != NULLCHAR) {
1514         while (*s == '\033') {
1515             while (*s != NULLCHAR && !isalpha(*s)) s++;
1516             if (*s != NULLCHAR) s++;
1517         }
1518         while (*s != NULLCHAR && *s != '\033') {
1519             *p++ = *s++;
1520         }
1521     }
1522     *p = NULLCHAR;
1523     return retbuf;
1524 }
1525
1526 char *variantNames[] = VARIANT_NAMES;
1527 char *
1528 VariantName(v)
1529      VariantClass v;
1530 {
1531     return variantNames[v];
1532 }
1533
1534
1535 /* Identify a variant from the strings the chess servers use or the
1536    PGN Variant tag names we use. */
1537 VariantClass
1538 StringToVariant(e)
1539      char *e;
1540 {
1541     char *p;
1542     int wnum = -1;
1543     VariantClass v = VariantNormal;
1544     int i, found = FALSE;
1545     char buf[MSG_SIZ];
1546
1547     if (!e) return v;
1548
1549     /* [HGM] skip over optional board-size prefixes */
1550     if( sscanf(e, "%dx%d_", &i, &i) == 2 ||
1551         sscanf(e, "%dx%d+%d_", &i, &i, &i) == 3 ) {
1552         while( *e++ != '_');
1553     }
1554
1555     if(StrCaseStr(e, "misc/")) { // [HGM] on FICS, misc/shogi is not shogi
1556         v = VariantNormal;
1557         found = TRUE;
1558     } else
1559     for (i=0; i<sizeof(variantNames)/sizeof(char*); i++) {
1560       if (StrCaseStr(e, variantNames[i])) {
1561         v = (VariantClass) i;
1562         found = TRUE;
1563         break;
1564       }
1565     }
1566
1567     if (!found) {
1568       if ((StrCaseStr(e, "fischer") && StrCaseStr(e, "random"))
1569           || StrCaseStr(e, "wild/fr")
1570           || StrCaseStr(e, "frc") || StrCaseStr(e, "960")) {
1571         v = VariantFischeRandom;
1572       } else if ((i = 4, p = StrCaseStr(e, "wild")) ||
1573                  (i = 1, p = StrCaseStr(e, "w"))) {
1574         p += i;
1575         while (*p && (isspace(*p) || *p == '(' || *p == '/')) p++;
1576         if (isdigit(*p)) {
1577           wnum = atoi(p);
1578         } else {
1579           wnum = -1;
1580         }
1581         switch (wnum) {
1582         case 0: /* FICS only, actually */
1583         case 1:
1584           /* Castling legal even if K starts on d-file */
1585           v = VariantWildCastle;
1586           break;
1587         case 2:
1588         case 3:
1589         case 4:
1590           /* Castling illegal even if K & R happen to start in
1591              normal positions. */
1592           v = VariantNoCastle;
1593           break;
1594         case 5:
1595         case 7:
1596         case 8:
1597         case 10:
1598         case 11:
1599         case 12:
1600         case 13:
1601         case 14:
1602         case 15:
1603         case 18:
1604         case 19:
1605           /* Castling legal iff K & R start in normal positions */
1606           v = VariantNormal;
1607           break;
1608         case 6:
1609         case 20:
1610         case 21:
1611           /* Special wilds for position setup; unclear what to do here */
1612           v = VariantLoadable;
1613           break;
1614         case 9:
1615           /* Bizarre ICC game */
1616           v = VariantTwoKings;
1617           break;
1618         case 16:
1619           v = VariantKriegspiel;
1620           break;
1621         case 17:
1622           v = VariantLosers;
1623           break;
1624         case 22:
1625           v = VariantFischeRandom;
1626           break;
1627         case 23:
1628           v = VariantCrazyhouse;
1629           break;
1630         case 24:
1631           v = VariantBughouse;
1632           break;
1633         case 25:
1634           v = Variant3Check;
1635           break;
1636         case 26:
1637           /* Not quite the same as FICS suicide! */
1638           v = VariantGiveaway;
1639           break;
1640         case 27:
1641           v = VariantAtomic;
1642           break;
1643         case 28:
1644           v = VariantShatranj;
1645           break;
1646
1647         /* Temporary names for future ICC types.  The name *will* change in
1648            the next xboard/WinBoard release after ICC defines it. */
1649         case 29:
1650           v = Variant29;
1651           break;
1652         case 30:
1653           v = Variant30;
1654           break;
1655         case 31:
1656           v = Variant31;
1657           break;
1658         case 32:
1659           v = Variant32;
1660           break;
1661         case 33:
1662           v = Variant33;
1663           break;
1664         case 34:
1665           v = Variant34;
1666           break;
1667         case 35:
1668           v = Variant35;
1669           break;
1670         case 36:
1671           v = Variant36;
1672           break;
1673         case 37:
1674           v = VariantShogi;
1675           break;
1676         case 38:
1677           v = VariantXiangqi;
1678           break;
1679         case 39:
1680           v = VariantCourier;
1681           break;
1682         case 40:
1683           v = VariantGothic;
1684           break;
1685         case 41:
1686           v = VariantCapablanca;
1687           break;
1688         case 42:
1689           v = VariantKnightmate;
1690           break;
1691         case 43:
1692           v = VariantFairy;
1693           break;
1694         case 44:
1695           v = VariantCylinder;
1696           break;
1697         case 45:
1698           v = VariantFalcon;
1699           break;
1700         case 46:
1701           v = VariantCapaRandom;
1702           break;
1703         case 47:
1704           v = VariantBerolina;
1705           break;
1706         case 48:
1707           v = VariantJanus;
1708           break;
1709         case 49:
1710           v = VariantSuper;
1711           break;
1712         case 50:
1713           v = VariantGreat;
1714           break;
1715         case -1:
1716           /* Found "wild" or "w" in the string but no number;
1717              must assume it's normal chess. */
1718           v = VariantNormal;
1719           break;
1720         default:
1721           sprintf(buf, _("Unknown wild type %d"), wnum);
1722           DisplayError(buf, 0);
1723           v = VariantUnknown;
1724           break;
1725         }
1726       }
1727     }
1728     if (appData.debugMode) {
1729       fprintf(debugFP, _("recognized '%s' (%d) as variant %s\n"),
1730               e, wnum, VariantName(v));
1731     }
1732     return v;
1733 }
1734
1735 static int leftover_start = 0, leftover_len = 0;
1736 char star_match[STAR_MATCH_N][MSG_SIZ];
1737
1738 /* Test whether pattern is present at &buf[*index]; if so, return TRUE,
1739    advance *index beyond it, and set leftover_start to the new value of
1740    *index; else return FALSE.  If pattern contains the character '*', it
1741    matches any sequence of characters not containing '\r', '\n', or the
1742    character following the '*' (if any), and the matched sequence(s) are
1743    copied into star_match.
1744    */
1745 int
1746 looking_at(buf, index, pattern)
1747      char *buf;
1748      int *index;
1749      char *pattern;
1750 {
1751     char *bufp = &buf[*index], *patternp = pattern;
1752     int star_count = 0;
1753     char *matchp = star_match[0];
1754
1755     for (;;) {
1756         if (*patternp == NULLCHAR) {
1757             *index = leftover_start = bufp - buf;
1758             *matchp = NULLCHAR;
1759             return TRUE;
1760         }
1761         if (*bufp == NULLCHAR) return FALSE;
1762         if (*patternp == '*') {
1763             if (*bufp == *(patternp + 1)) {
1764                 *matchp = NULLCHAR;
1765                 matchp = star_match[++star_count];
1766                 patternp += 2;
1767                 bufp++;
1768                 continue;
1769             } else if (*bufp == '\n' || *bufp == '\r') {
1770                 patternp++;
1771                 if (*patternp == NULLCHAR)
1772                   continue;
1773                 else
1774                   return FALSE;
1775             } else {
1776                 *matchp++ = *bufp++;
1777                 continue;
1778             }
1779         }
1780         if (*patternp != *bufp) return FALSE;
1781         patternp++;
1782         bufp++;
1783     }
1784 }
1785
1786 void
1787 SendToPlayer(data, length)
1788      char *data;
1789      int length;
1790 {
1791     int error, outCount;
1792     outCount = OutputToProcess(NoProc, data, length, &error);
1793     if (outCount < length) {
1794         DisplayFatalError(_("Error writing to display"), error, 1);
1795     }
1796 }
1797
1798 void
1799 PackHolding(packed, holding)
1800      char packed[];
1801      char *holding;
1802 {
1803     char *p = holding;
1804     char *q = packed;
1805     int runlength = 0;
1806     int curr = 9999;
1807     do {
1808         if (*p == curr) {
1809             runlength++;
1810         } else {
1811             switch (runlength) {
1812               case 0:
1813                 break;
1814               case 1:
1815                 *q++ = curr;
1816                 break;
1817               case 2:
1818                 *q++ = curr;
1819                 *q++ = curr;
1820                 break;
1821               default:
1822                 sprintf(q, "%d", runlength);
1823                 while (*q) q++;
1824                 *q++ = curr;
1825                 break;
1826             }
1827             runlength = 1;
1828             curr = *p;
1829         }
1830     } while (*p++);
1831     *q = NULLCHAR;
1832 }
1833
1834 /* Telnet protocol requests from the front end */
1835 void
1836 TelnetRequest(ddww, option)
1837      unsigned char ddww, option;
1838 {
1839     unsigned char msg[3];
1840     int outCount, outError;
1841
1842     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet) return;
1843
1844     if (appData.debugMode) {
1845         char buf1[8], buf2[8], *ddwwStr, *optionStr;
1846         switch (ddww) {
1847           case TN_DO:
1848             ddwwStr = "DO";
1849             break;
1850           case TN_DONT:
1851             ddwwStr = "DONT";
1852             break;
1853           case TN_WILL:
1854             ddwwStr = "WILL";
1855             break;
1856           case TN_WONT:
1857             ddwwStr = "WONT";
1858             break;
1859           default:
1860             ddwwStr = buf1;
1861             sprintf(buf1, "%d", ddww);
1862             break;
1863         }
1864         switch (option) {
1865           case TN_ECHO:
1866             optionStr = "ECHO";
1867             break;
1868           default:
1869             optionStr = buf2;
1870             sprintf(buf2, "%d", option);
1871             break;
1872         }
1873         fprintf(debugFP, ">%s %s ", ddwwStr, optionStr);
1874     }
1875     msg[0] = TN_IAC;
1876     msg[1] = ddww;
1877     msg[2] = option;
1878     outCount = OutputToProcess(icsPR, (char *)msg, 3, &outError);
1879     if (outCount < 3) {
1880         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1881     }
1882 }
1883
1884 void
1885 DoEcho()
1886 {
1887     if (!appData.icsActive) return;
1888     TelnetRequest(TN_DO, TN_ECHO);
1889 }
1890
1891 void
1892 DontEcho()
1893 {
1894     if (!appData.icsActive) return;
1895     TelnetRequest(TN_DONT, TN_ECHO);
1896 }
1897
1898 void
1899 CopyHoldings(Board board, char *holdings, ChessSquare lowestPiece)
1900 {
1901     /* put the holdings sent to us by the server on the board holdings area */
1902     int i, j, holdingsColumn, holdingsStartRow, direction, countsColumn;
1903     char p;
1904     ChessSquare piece;
1905
1906     if(gameInfo.holdingsWidth < 2)  return;
1907     if(gameInfo.variant != VariantBughouse && board[BOARD_SIZE-1][BOARD_SIZE-2])
1908         return; // prevent overwriting by pre-board holdings
1909
1910     if( (int)lowestPiece >= BlackPawn ) {
1911         holdingsColumn = 0;
1912         countsColumn = 1;
1913         holdingsStartRow = BOARD_HEIGHT-1;
1914         direction = -1;
1915     } else {
1916         holdingsColumn = BOARD_WIDTH-1;
1917         countsColumn = BOARD_WIDTH-2;
1918         holdingsStartRow = 0;
1919         direction = 1;
1920     }
1921
1922     for(i=0; i<BOARD_HEIGHT; i++) { /* clear holdings */
1923         board[i][holdingsColumn] = EmptySquare;
1924         board[i][countsColumn]   = (ChessSquare) 0;
1925     }
1926     while( (p=*holdings++) != NULLCHAR ) {
1927         piece = CharToPiece( ToUpper(p) );
1928         if(piece == EmptySquare) continue;
1929         /*j = (int) piece - (int) WhitePawn;*/
1930         j = PieceToNumber(piece);
1931         if(j >= gameInfo.holdingsSize) continue; /* ignore pieces that do not fit */
1932         if(j < 0) continue;               /* should not happen */
1933         piece = (ChessSquare) ( (int)piece + (int)lowestPiece );
1934         board[holdingsStartRow+j*direction][holdingsColumn] = piece;
1935         board[holdingsStartRow+j*direction][countsColumn]++;
1936     }
1937 }
1938
1939
1940 void
1941 VariantSwitch(Board board, VariantClass newVariant)
1942 {
1943    int newHoldingsWidth, newWidth = 8, newHeight = 8, i, j;
1944    Board oldBoard;
1945
1946    startedFromPositionFile = FALSE;
1947    if(gameInfo.variant == newVariant) return;
1948
1949    /* [HGM] This routine is called each time an assignment is made to
1950     * gameInfo.variant during a game, to make sure the board sizes
1951     * are set to match the new variant. If that means adding or deleting
1952     * holdings, we shift the playing board accordingly
1953     * This kludge is needed because in ICS observe mode, we get boards
1954     * of an ongoing game without knowing the variant, and learn about the
1955     * latter only later. This can be because of the move list we requested,
1956     * in which case the game history is refilled from the beginning anyway,
1957     * but also when receiving holdings of a crazyhouse game. In the latter
1958     * case we want to add those holdings to the already received position.
1959     */
1960
1961
1962    if (appData.debugMode) {
1963      fprintf(debugFP, "Switch board from %s to %s\n",
1964              VariantName(gameInfo.variant), VariantName(newVariant));
1965      setbuf(debugFP, NULL);
1966    }
1967    shuffleOpenings = 0;       /* [HGM] shuffle */
1968    gameInfo.holdingsSize = 5; /* [HGM] prepare holdings */
1969    switch(newVariant)
1970      {
1971      case VariantShogi:
1972        newWidth = 9;  newHeight = 9;
1973        gameInfo.holdingsSize = 7;
1974      case VariantBughouse:
1975      case VariantCrazyhouse:
1976        newHoldingsWidth = 2; break;
1977      case VariantGreat:
1978        newWidth = 10;
1979      case VariantSuper:
1980        newHoldingsWidth = 2;
1981        gameInfo.holdingsSize = 8;
1982        break;
1983      case VariantGothic:
1984      case VariantCapablanca:
1985      case VariantCapaRandom:
1986        newWidth = 10;
1987      default:
1988        newHoldingsWidth = gameInfo.holdingsSize = 0;
1989      };
1990
1991    if(newWidth  != gameInfo.boardWidth  ||
1992       newHeight != gameInfo.boardHeight ||
1993       newHoldingsWidth != gameInfo.holdingsWidth ) {
1994
1995      /* shift position to new playing area, if needed */
1996      if(newHoldingsWidth > gameInfo.holdingsWidth) {
1997        for(i=0; i<BOARD_HEIGHT; i++)
1998          for(j=BOARD_RGHT-1; j>=BOARD_LEFT; j--)
1999            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2000              board[i][j];
2001        for(i=0; i<newHeight; i++) {
2002          board[i][0] = board[i][newWidth+2*newHoldingsWidth-1] = EmptySquare;
2003          board[i][1] = board[i][newWidth+2*newHoldingsWidth-2] = (ChessSquare) 0;
2004        }
2005      } else if(newHoldingsWidth < gameInfo.holdingsWidth) {
2006        for(i=0; i<BOARD_HEIGHT; i++)
2007          for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
2008            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2009              board[i][j];
2010      }
2011      gameInfo.boardWidth  = newWidth;
2012      gameInfo.boardHeight = newHeight;
2013      gameInfo.holdingsWidth = newHoldingsWidth;
2014      gameInfo.variant = newVariant;
2015      InitDrawingSizes(-2, 0);
2016    } else gameInfo.variant = newVariant;
2017    CopyBoard(oldBoard, board);   // remember correctly formatted board
2018      InitPosition(FALSE);          /* this sets up board[0], but also other stuff        */
2019    DrawPosition(TRUE, currentMove ? boards[currentMove] : oldBoard);
2020 }
2021
2022 static int loggedOn = FALSE;
2023
2024 /*-- Game start info cache: --*/
2025 int gs_gamenum;
2026 char gs_kind[MSG_SIZ];
2027 static char player1Name[128] = "";
2028 static char player2Name[128] = "";
2029 static char cont_seq[] = "\n\\   ";
2030 static int player1Rating = -1;
2031 static int player2Rating = -1;
2032 /*----------------------------*/
2033
2034 ColorClass curColor = ColorNormal;
2035 int suppressKibitz = 0;
2036
2037 void
2038 read_from_ics(isr, closure, data, count, error)
2039      InputSourceRef isr;
2040      VOIDSTAR closure;
2041      char *data;
2042      int count;
2043      int error;
2044 {
2045 #define BUF_SIZE 8192
2046 #define STARTED_NONE 0
2047 #define STARTED_MOVES 1
2048 #define STARTED_BOARD 2
2049 #define STARTED_OBSERVE 3
2050 #define STARTED_HOLDINGS 4
2051 #define STARTED_CHATTER 5
2052 #define STARTED_COMMENT 6
2053 #define STARTED_MOVES_NOHIDE 7
2054
2055     static int started = STARTED_NONE;
2056     static char parse[20000];
2057     static int parse_pos = 0;
2058     static char buf[BUF_SIZE + 1];
2059     static int firstTime = TRUE, intfSet = FALSE;
2060     static ColorClass prevColor = ColorNormal;
2061     static int savingComment = FALSE;
2062     static int cmatch = 0; // continuation sequence match
2063     char *bp;
2064     char str[500];
2065     int i, oldi;
2066     int buf_len;
2067     int next_out;
2068     int tkind;
2069     int backup;    /* [DM] For zippy color lines */
2070     char *p;
2071     char talker[MSG_SIZ]; // [HGM] chat
2072     int channel;
2073
2074     if (appData.debugMode) {
2075       if (!error) {
2076         fprintf(debugFP, "<ICS: ");
2077         show_bytes(debugFP, data, count);
2078         fprintf(debugFP, "\n");
2079       }
2080     }
2081
2082     if (appData.debugMode) { int f = forwardMostMove;
2083         fprintf(debugFP, "ics input %d, castling = %d %d %d %d %d %d\n", f,
2084                 castlingRights[f][0],castlingRights[f][1],castlingRights[f][2],castlingRights[f][3],castlingRights[f][4],castlingRights[f][5]);
2085     }
2086     if (count > 0) {
2087         /* If last read ended with a partial line that we couldn't parse,
2088            prepend it to the new read and try again. */
2089         if (leftover_len > 0) {
2090             for (i=0; i<leftover_len; i++)
2091               buf[i] = buf[leftover_start + i];
2092         }
2093
2094     /* copy new characters into the buffer */
2095     bp = buf + leftover_len;
2096     buf_len=leftover_len;
2097     for (i=0; i<count; i++)
2098     {
2099         // ignore these
2100         if (data[i] == '\r')
2101             continue;
2102
2103         // join lines split by ICS?
2104         if (!appData.noJoin)
2105         {
2106             /*
2107                 Joining just consists of finding matches against the
2108                 continuation sequence, and discarding that sequence
2109                 if found instead of copying it.  So, until a match
2110                 fails, there's nothing to do since it might be the
2111                 complete sequence, and thus, something we don't want
2112                 copied.
2113             */
2114             if (data[i] == cont_seq[cmatch])
2115             {
2116                 cmatch++;
2117                 if (cmatch == strlen(cont_seq))
2118                 {
2119                     cmatch = 0; // complete match.  just reset the counter
2120
2121                     /*
2122                         it's possible for the ICS to not include the space
2123                         at the end of the last word, making our [correct]
2124                         join operation fuse two separate words.  the server
2125                         does this when the space occurs at the width setting.
2126                     */
2127                     if (!buf_len || buf[buf_len-1] != ' ')
2128                     {
2129                         *bp++ = ' ';
2130                         buf_len++;
2131                     }
2132                 }
2133                 continue;
2134             }
2135             else if (cmatch)
2136             {
2137                 /*
2138                     match failed, so we have to copy what matched before
2139                     falling through and copying this character.  In reality,
2140                     this will only ever be just the newline character, but
2141                     it doesn't hurt to be precise.
2142                 */
2143                 strncpy(bp, cont_seq, cmatch);
2144                 bp += cmatch;
2145                 buf_len += cmatch;
2146                 cmatch = 0;
2147             }
2148         }
2149
2150         // copy this char
2151         *bp++ = data[i];
2152         buf_len++;
2153     }
2154
2155         buf[buf_len] = NULLCHAR;
2156         next_out = leftover_len;
2157         leftover_start = 0;
2158
2159         i = 0;
2160         while (i < buf_len) {
2161             /* Deal with part of the TELNET option negotiation
2162                protocol.  We refuse to do anything beyond the
2163                defaults, except that we allow the WILL ECHO option,
2164                which ICS uses to turn off password echoing when we are
2165                directly connected to it.  We reject this option
2166                if localLineEditing mode is on (always on in xboard)
2167                and we are talking to port 23, which might be a real
2168                telnet server that will try to keep WILL ECHO on permanently.
2169              */
2170             if (buf_len - i >= 3 && (unsigned char) buf[i] == TN_IAC) {
2171                 static int remoteEchoOption = FALSE; /* telnet ECHO option */
2172                 unsigned char option;
2173                 oldi = i;
2174                 switch ((unsigned char) buf[++i]) {
2175                   case TN_WILL:
2176                     if (appData.debugMode)
2177                       fprintf(debugFP, "\n<WILL ");
2178                     switch (option = (unsigned char) buf[++i]) {
2179                       case TN_ECHO:
2180                         if (appData.debugMode)
2181                           fprintf(debugFP, "ECHO ");
2182                         /* Reply only if this is a change, according
2183                            to the protocol rules. */
2184                         if (remoteEchoOption) break;
2185                         if (appData.localLineEditing &&
2186                             atoi(appData.icsPort) == TN_PORT) {
2187                             TelnetRequest(TN_DONT, TN_ECHO);
2188                         } else {
2189                             EchoOff();
2190                             TelnetRequest(TN_DO, TN_ECHO);
2191                             remoteEchoOption = TRUE;
2192                         }
2193                         break;
2194                       default:
2195                         if (appData.debugMode)
2196                           fprintf(debugFP, "%d ", option);
2197                         /* Whatever this is, we don't want it. */
2198                         TelnetRequest(TN_DONT, option);
2199                         break;
2200                     }
2201                     break;
2202                   case TN_WONT:
2203                     if (appData.debugMode)
2204                       fprintf(debugFP, "\n<WONT ");
2205                     switch (option = (unsigned char) buf[++i]) {
2206                       case TN_ECHO:
2207                         if (appData.debugMode)
2208                           fprintf(debugFP, "ECHO ");
2209                         /* Reply only if this is a change, according
2210                            to the protocol rules. */
2211                         if (!remoteEchoOption) break;
2212                         EchoOn();
2213                         TelnetRequest(TN_DONT, TN_ECHO);
2214                         remoteEchoOption = FALSE;
2215                         break;
2216                       default:
2217                         if (appData.debugMode)
2218                           fprintf(debugFP, "%d ", (unsigned char) option);
2219                         /* Whatever this is, it must already be turned
2220                            off, because we never agree to turn on
2221                            anything non-default, so according to the
2222                            protocol rules, we don't reply. */
2223                         break;
2224                     }
2225                     break;
2226                   case TN_DO:
2227                     if (appData.debugMode)
2228                       fprintf(debugFP, "\n<DO ");
2229                     switch (option = (unsigned char) buf[++i]) {
2230                       default:
2231                         /* Whatever this is, we refuse to do it. */
2232                         if (appData.debugMode)
2233                           fprintf(debugFP, "%d ", option);
2234                         TelnetRequest(TN_WONT, option);
2235                         break;
2236                     }
2237                     break;
2238                   case TN_DONT:
2239                     if (appData.debugMode)
2240                       fprintf(debugFP, "\n<DONT ");
2241                     switch (option = (unsigned char) buf[++i]) {
2242                       default:
2243                         if (appData.debugMode)
2244                           fprintf(debugFP, "%d ", option);
2245                         /* Whatever this is, we are already not doing
2246                            it, because we never agree to do anything
2247                            non-default, so according to the protocol
2248                            rules, we don't reply. */
2249                         break;
2250                     }
2251                     break;
2252                   case TN_IAC:
2253                     if (appData.debugMode)
2254                       fprintf(debugFP, "\n<IAC ");
2255                     /* Doubled IAC; pass it through */
2256                     i--;
2257                     break;
2258                   default:
2259                     if (appData.debugMode)
2260                       fprintf(debugFP, "\n<%d ", (unsigned char) buf[i]);
2261                     /* Drop all other telnet commands on the floor */
2262                     break;
2263                 }
2264                 if (oldi > next_out)
2265                   SendToPlayer(&buf[next_out], oldi - next_out);
2266                 if (++i > next_out)
2267                   next_out = i;
2268                 continue;
2269             }
2270
2271             /* OK, this at least will *usually* work */
2272             if (!loggedOn && looking_at(buf, &i, "ics%")) {
2273                 loggedOn = TRUE;
2274             }
2275
2276             if (loggedOn && !intfSet) {
2277                 if (ics_type == ICS_ICC) {
2278                   sprintf(str,
2279                           "/set-quietly interface %s\n/set-quietly style 12\n",
2280                           programVersion);
2281                 } else if (ics_type == ICS_CHESSNET) {
2282                   sprintf(str, "/style 12\n");
2283                 } else {
2284                   strcpy(str, "alias $ @\n$set interface ");
2285                   strcat(str, programVersion);
2286                   strcat(str, "\n$iset startpos 1\n$iset ms 1\n");
2287 #ifdef WIN32
2288                   strcat(str, "$iset nohighlight 1\n");
2289 #endif
2290                   strcat(str, "$iset lock 1\n$style 12\n");
2291                 }
2292                 SendToICS(str);
2293                 NotifyFrontendLogin();
2294                 intfSet = TRUE;
2295             }
2296
2297             if (started == STARTED_COMMENT) {
2298                 /* Accumulate characters in comment */
2299                 parse[parse_pos++] = buf[i];
2300                 if (buf[i] == '\n') {
2301                     parse[parse_pos] = NULLCHAR;
2302                     if(chattingPartner>=0) {
2303                         char mess[MSG_SIZ];
2304                         sprintf(mess, "%s%s", talker, parse);
2305                         OutputChatMessage(chattingPartner, mess);
2306                         chattingPartner = -1;
2307                     } else
2308                     if(!suppressKibitz) // [HGM] kibitz
2309                         AppendComment(forwardMostMove, StripHighlight(parse));
2310                     else { // [HGM kibitz: divert memorized engine kibitz to engine-output window
2311                         int nrDigit = 0, nrAlph = 0, i;
2312                         if(parse_pos > MSG_SIZ - 30) // defuse unreasonably long input
2313                         { parse_pos = MSG_SIZ-30; parse[parse_pos - 1] = '\n'; }
2314                         parse[parse_pos] = NULLCHAR;
2315                         // try to be smart: if it does not look like search info, it should go to
2316                         // ICS interaction window after all, not to engine-output window.
2317                         for(i=0; i<parse_pos; i++) { // count letters and digits
2318                             nrDigit += (parse[i] >= '0' && parse[i] <= '9');
2319                             nrAlph  += (parse[i] >= 'a' && parse[i] <= 'z');
2320                             nrAlph  += (parse[i] >= 'A' && parse[i] <= 'Z');
2321                         }
2322                         if(nrAlph < 9*nrDigit) { // if more than 10% digit we assume search info
2323                             int depth=0; float score;
2324                             if(sscanf(parse, "!!! %f/%d", &score, &depth) == 2 && depth>0) {
2325                                 // [HGM] kibitz: save kibitzed opponent info for PGN and eval graph
2326                                 pvInfoList[forwardMostMove-1].depth = depth;
2327                                 pvInfoList[forwardMostMove-1].score = 100*score;
2328                             }
2329                             OutputKibitz(suppressKibitz, parse);
2330                         } else {
2331                             char tmp[MSG_SIZ];
2332                             sprintf(tmp, _("your opponent kibitzes: %s"), parse);
2333                             SendToPlayer(tmp, strlen(tmp));
2334                         }
2335                     }
2336                     started = STARTED_NONE;
2337                 } else {
2338                     /* Don't match patterns against characters in chatter */
2339                     i++;
2340                     continue;
2341                 }
2342             }
2343             if (started == STARTED_CHATTER) {
2344                 if (buf[i] != '\n') {
2345                     /* Don't match patterns against characters in chatter */
2346                     i++;
2347                     continue;
2348                 }
2349                 started = STARTED_NONE;
2350             }
2351
2352             /* Kludge to deal with rcmd protocol */
2353             if (firstTime && looking_at(buf, &i, "\001*")) {
2354                 DisplayFatalError(&buf[1], 0, 1);
2355                 continue;
2356             } else {
2357                 firstTime = FALSE;
2358             }
2359
2360             if (!loggedOn && looking_at(buf, &i, "chessclub.com")) {
2361                 ics_type = ICS_ICC;
2362                 ics_prefix = "/";
2363                 if (appData.debugMode)
2364                   fprintf(debugFP, "ics_type %d\n", ics_type);
2365                 continue;
2366             }
2367             if (!loggedOn && looking_at(buf, &i, "freechess.org")) {
2368                 ics_type = ICS_FICS;
2369                 ics_prefix = "$";
2370                 if (appData.debugMode)
2371                   fprintf(debugFP, "ics_type %d\n", ics_type);
2372                 continue;
2373             }
2374             if (!loggedOn && looking_at(buf, &i, "chess.net")) {
2375                 ics_type = ICS_CHESSNET;
2376                 ics_prefix = "/";
2377                 if (appData.debugMode)
2378                   fprintf(debugFP, "ics_type %d\n", ics_type);
2379                 continue;
2380             }
2381
2382             if (!loggedOn &&
2383                 (looking_at(buf, &i, "\"*\" is *a registered name") ||
2384                  looking_at(buf, &i, "Logging you in as \"*\"") ||
2385                  looking_at(buf, &i, "will be \"*\""))) {
2386               strcpy(ics_handle, star_match[0]);
2387               continue;
2388             }
2389
2390             if (loggedOn && !have_set_title && ics_handle[0] != NULLCHAR) {
2391               char buf[MSG_SIZ];
2392               snprintf(buf, sizeof(buf), "%s@%s", ics_handle, appData.icsHost);
2393               DisplayIcsInteractionTitle(buf);
2394               have_set_title = TRUE;
2395             }
2396
2397             /* skip finger notes */
2398             if (started == STARTED_NONE &&
2399                 ((buf[i] == ' ' && isdigit(buf[i+1])) ||
2400                  (buf[i] == '1' && buf[i+1] == '0')) &&
2401                 buf[i+2] == ':' && buf[i+3] == ' ') {
2402               started = STARTED_CHATTER;
2403               i += 3;
2404               continue;
2405             }
2406
2407             /* skip formula vars */
2408             if (started == STARTED_NONE &&
2409                 buf[i] == 'f' && isdigit(buf[i+1]) && buf[i+2] == ':') {
2410               started = STARTED_CHATTER;
2411               i += 3;
2412               continue;
2413             }
2414
2415             oldi = i;
2416             // [HGM] kibitz: try to recognize opponent engine-score kibitzes, to divert them to engine-output window
2417             if (appData.autoKibitz && started == STARTED_NONE &&
2418                 !appData.icsEngineAnalyze &&                     // [HGM] [DM] ICS analyze
2419                 (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack || gameMode == IcsObserving)) {
2420                 if(looking_at(buf, &i, "* kibitzes: ") &&
2421                    (StrStr(star_match[0], gameInfo.white) == star_match[0] ||
2422                     StrStr(star_match[0], gameInfo.black) == star_match[0]   )) { // kibitz of self or opponent
2423                         suppressKibitz = TRUE;
2424                         if((StrStr(star_match[0], gameInfo.white) == star_match[0]
2425                                 && (gameMode == IcsPlayingWhite)) ||
2426                            (StrStr(star_match[0], gameInfo.black) == star_match[0]
2427                                 && (gameMode == IcsPlayingBlack))   ) // opponent kibitz
2428                             started = STARTED_CHATTER; // own kibitz we simply discard
2429                         else {
2430                             started = STARTED_COMMENT; // make sure it will be collected in parse[]
2431                             parse_pos = 0; parse[0] = NULLCHAR;
2432                             savingComment = TRUE;
2433                             suppressKibitz = gameMode != IcsObserving ? 2 :
2434                                 (StrStr(star_match[0], gameInfo.white) == NULL) + 1;
2435                         }
2436                         continue;
2437                 } else
2438                 if(looking_at(buf, &i, "kibitzed to")) { // suppress the acknowledgements of our own autoKibitz
2439                     started = STARTED_CHATTER;
2440                     suppressKibitz = TRUE;
2441                 }
2442             } // [HGM] kibitz: end of patch
2443
2444 //if(appData.debugMode) fprintf(debugFP, "hunt for tell, buf = %s\n", buf+i);
2445
2446             // [HGM] chat: intercept tells by users for which we have an open chat window
2447             channel = -1;
2448             if(started == STARTED_NONE && (looking_at(buf, &i, "* tells you:") || looking_at(buf, &i, "* says:") ||
2449                                            looking_at(buf, &i, "* whispers:") ||
2450                                            looking_at(buf, &i, "*(*):") && (sscanf(star_match[1], "%d", &channel),1) ||
2451                                            looking_at(buf, &i, "*(*)(*):") && sscanf(star_match[2], "%d", &channel) == 1 )) {
2452                 int p;
2453                 sscanf(star_match[0], "%[^(]", talker+1); // strip (C) or (U) off ICS handle
2454                 chattingPartner = -1;
2455
2456                 if(channel >= 0) // channel broadcast; look if there is a chatbox for this channel
2457                 for(p=0; p<MAX_CHAT; p++) {
2458                     if(channel == atoi(chatPartner[p])) {
2459                     talker[0] = '['; strcat(talker, "]");
2460                     chattingPartner = p; break;
2461                     }
2462                 } else
2463                 if(buf[i-3] == 'r') // whisper; look if there is a WHISPER chatbox
2464                 for(p=0; p<MAX_CHAT; p++) {
2465                     if(!strcmp("WHISPER", chatPartner[p])) {
2466                         talker[0] = '['; strcat(talker, "]");
2467                         chattingPartner = p; break;
2468                     }
2469                 }
2470                 if(chattingPartner<0) // if not, look if there is a chatbox for this indivdual
2471                 for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
2472                     talker[0] = 0;
2473                     chattingPartner = p; break;
2474                 }
2475                 if(chattingPartner<0) i = oldi; else {
2476                     started = STARTED_COMMENT;
2477                     parse_pos = 0; parse[0] = NULLCHAR;
2478                     savingComment = TRUE;
2479                     suppressKibitz = TRUE;
2480                 }
2481             } // [HGM] chat: end of patch
2482
2483             if (appData.zippyTalk || appData.zippyPlay) {
2484                 /* [DM] Backup address for color zippy lines */
2485                 backup = i;
2486 #if ZIPPY
2487        #ifdef WIN32
2488                if (loggedOn == TRUE)
2489                        if (ZippyControl(buf, &backup) || ZippyConverse(buf, &backup) ||
2490                           (appData.zippyPlay && ZippyMatch(buf, &backup)));
2491        #else
2492                 if (ZippyControl(buf, &i) ||
2493                     ZippyConverse(buf, &i) ||
2494                     (appData.zippyPlay && ZippyMatch(buf, &i))) {
2495                       loggedOn = TRUE;
2496                       if (!appData.colorize) continue;
2497                 }
2498        #endif
2499 #endif
2500             } // [DM] 'else { ' deleted
2501                 if (
2502                     /* Regular tells and says */
2503                     (tkind = 1, looking_at(buf, &i, "* tells you: ")) ||
2504                     looking_at(buf, &i, "* (your partner) tells you: ") ||
2505                     looking_at(buf, &i, "* says: ") ||
2506                     /* Don't color "message" or "messages" output */
2507                     (tkind = 5, looking_at(buf, &i, "*. * (*:*): ")) ||
2508                     looking_at(buf, &i, "*. * at *:*: ") ||
2509                     looking_at(buf, &i, "--* (*:*): ") ||
2510                     /* Message notifications (same color as tells) */
2511                     looking_at(buf, &i, "* has left a message ") ||
2512                     looking_at(buf, &i, "* just sent you a message:\n") ||
2513                     /* Whispers and kibitzes */
2514                     (tkind = 2, looking_at(buf, &i, "* whispers: ")) ||
2515                     looking_at(buf, &i, "* kibitzes: ") ||
2516                     /* Channel tells */
2517                     (tkind = 3, looking_at(buf, &i, "*(*: "))) {
2518
2519                   if (tkind == 1 && strchr(star_match[0], ':')) {
2520                       /* Avoid "tells you:" spoofs in channels */
2521                      tkind = 3;
2522                   }
2523                   if (star_match[0][0] == NULLCHAR ||
2524                       strchr(star_match[0], ' ') ||
2525                       (tkind == 3 && strchr(star_match[1], ' '))) {
2526                     /* Reject bogus matches */
2527                     i = oldi;
2528                   } else {
2529                     if (appData.colorize) {
2530                       if (oldi > next_out) {
2531                         SendToPlayer(&buf[next_out], oldi - next_out);
2532                         next_out = oldi;
2533                       }
2534                       switch (tkind) {
2535                       case 1:
2536                         Colorize(ColorTell, FALSE);
2537                         curColor = ColorTell;
2538                         break;
2539                       case 2:
2540                         Colorize(ColorKibitz, FALSE);
2541                         curColor = ColorKibitz;
2542                         break;
2543                       case 3:
2544                         p = strrchr(star_match[1], '(');
2545                         if (p == NULL) {
2546                           p = star_match[1];
2547                         } else {
2548                           p++;
2549                         }
2550                         if (atoi(p) == 1) {
2551                           Colorize(ColorChannel1, FALSE);
2552                           curColor = ColorChannel1;
2553                         } else {
2554                           Colorize(ColorChannel, FALSE);
2555                           curColor = ColorChannel;
2556                         }
2557                         break;
2558                       case 5:
2559                         curColor = ColorNormal;
2560                         break;
2561                       }
2562                     }
2563                     if (started == STARTED_NONE && appData.autoComment &&
2564                         (gameMode == IcsObserving ||
2565                          gameMode == IcsPlayingWhite ||
2566                          gameMode == IcsPlayingBlack)) {
2567                       parse_pos = i - oldi;
2568                       memcpy(parse, &buf[oldi], parse_pos);
2569                       parse[parse_pos] = NULLCHAR;
2570                       started = STARTED_COMMENT;
2571                       savingComment = TRUE;
2572                     } else {
2573                       started = STARTED_CHATTER;
2574                       savingComment = FALSE;
2575                     }
2576                     loggedOn = TRUE;
2577                     continue;
2578                   }
2579                 }
2580
2581                 if (looking_at(buf, &i, "* s-shouts: ") ||
2582                     looking_at(buf, &i, "* c-shouts: ")) {
2583                     if (appData.colorize) {
2584                         if (oldi > next_out) {
2585                             SendToPlayer(&buf[next_out], oldi - next_out);
2586                             next_out = oldi;
2587                         }
2588                         Colorize(ColorSShout, FALSE);
2589                         curColor = ColorSShout;
2590                     }
2591                     loggedOn = TRUE;
2592                     started = STARTED_CHATTER;
2593                     continue;
2594                 }
2595
2596                 if (looking_at(buf, &i, "--->")) {
2597                     loggedOn = TRUE;
2598                     continue;
2599                 }
2600
2601                 if (looking_at(buf, &i, "* shouts: ") ||
2602                     looking_at(buf, &i, "--> ")) {
2603                     if (appData.colorize) {
2604                         if (oldi > next_out) {
2605                             SendToPlayer(&buf[next_out], oldi - next_out);
2606                             next_out = oldi;
2607                         }
2608                         Colorize(ColorShout, FALSE);
2609                         curColor = ColorShout;
2610                     }
2611                     loggedOn = TRUE;
2612                     started = STARTED_CHATTER;
2613                     continue;
2614                 }
2615
2616                 if (looking_at( buf, &i, "Challenge:")) {
2617                     if (appData.colorize) {
2618                         if (oldi > next_out) {
2619                             SendToPlayer(&buf[next_out], oldi - next_out);
2620                             next_out = oldi;
2621                         }
2622                         Colorize(ColorChallenge, FALSE);
2623                         curColor = ColorChallenge;
2624                     }
2625                     loggedOn = TRUE;
2626                     continue;
2627                 }
2628
2629                 if (looking_at(buf, &i, "* offers you") ||
2630                     looking_at(buf, &i, "* offers to be") ||
2631                     looking_at(buf, &i, "* would like to") ||
2632                     looking_at(buf, &i, "* requests to") ||
2633                     looking_at(buf, &i, "Your opponent offers") ||
2634                     looking_at(buf, &i, "Your opponent requests")) {
2635
2636                     if (appData.colorize) {
2637                         if (oldi > next_out) {
2638                             SendToPlayer(&buf[next_out], oldi - next_out);
2639                             next_out = oldi;
2640                         }
2641                         Colorize(ColorRequest, FALSE);
2642                         curColor = ColorRequest;
2643                     }
2644                     continue;
2645                 }
2646
2647                 if (looking_at(buf, &i, "* (*) seeking")) {
2648                     if (appData.colorize) {
2649                         if (oldi > next_out) {
2650                             SendToPlayer(&buf[next_out], oldi - next_out);
2651                             next_out = oldi;
2652                         }
2653                         Colorize(ColorSeek, FALSE);
2654                         curColor = ColorSeek;
2655                     }
2656                     continue;
2657             }
2658
2659             if (looking_at(buf, &i, "\\   ")) {
2660                 if (prevColor != ColorNormal) {
2661                     if (oldi > next_out) {
2662                         SendToPlayer(&buf[next_out], oldi - next_out);
2663                         next_out = oldi;
2664                     }
2665                     Colorize(prevColor, TRUE);
2666                     curColor = prevColor;
2667                 }
2668                 if (savingComment) {
2669                     parse_pos = i - oldi;
2670                     memcpy(parse, &buf[oldi], parse_pos);
2671                     parse[parse_pos] = NULLCHAR;
2672                     started = STARTED_COMMENT;
2673                 } else {
2674                     started = STARTED_CHATTER;
2675                 }
2676                 continue;
2677             }
2678
2679             if (looking_at(buf, &i, "Black Strength :") ||
2680                 looking_at(buf, &i, "<<< style 10 board >>>") ||
2681                 looking_at(buf, &i, "<10>") ||
2682                 looking_at(buf, &i, "#@#")) {
2683                 /* Wrong board style */
2684                 loggedOn = TRUE;
2685                 SendToICS(ics_prefix);
2686                 SendToICS("set style 12\n");
2687                 SendToICS(ics_prefix);
2688                 SendToICS("refresh\n");
2689                 continue;
2690             }
2691
2692             if (!have_sent_ICS_logon && looking_at(buf, &i, "login:")) {
2693                 ICSInitScript();
2694                 have_sent_ICS_logon = 1;
2695                 continue;
2696             }
2697
2698             if (ics_getting_history != H_GETTING_MOVES /*smpos kludge*/ &&
2699                 (looking_at(buf, &i, "\n<12> ") ||
2700                  looking_at(buf, &i, "<12> "))) {
2701                 loggedOn = TRUE;
2702                 if (oldi > next_out) {
2703                     SendToPlayer(&buf[next_out], oldi - next_out);
2704                 }
2705                 next_out = i;
2706                 started = STARTED_BOARD;
2707                 parse_pos = 0;
2708                 continue;
2709             }
2710
2711             if ((started == STARTED_NONE && looking_at(buf, &i, "\n<b1> ")) ||
2712                 looking_at(buf, &i, "<b1> ")) {
2713                 if (oldi > next_out) {
2714                     SendToPlayer(&buf[next_out], oldi - next_out);
2715                 }
2716                 next_out = i;
2717                 started = STARTED_HOLDINGS;
2718                 parse_pos = 0;
2719                 continue;
2720             }
2721
2722             if (looking_at(buf, &i, "* *vs. * *--- *")) {
2723                 loggedOn = TRUE;
2724                 /* Header for a move list -- first line */
2725
2726                 switch (ics_getting_history) {
2727                   case H_FALSE:
2728                     switch (gameMode) {
2729                       case IcsIdle:
2730                       case BeginningOfGame:
2731                         /* User typed "moves" or "oldmoves" while we
2732                            were idle.  Pretend we asked for these
2733                            moves and soak them up so user can step
2734                            through them and/or save them.
2735                            */
2736                         Reset(FALSE, TRUE);
2737                         gameMode = IcsObserving;
2738                         ModeHighlight();
2739                         ics_gamenum = -1;
2740                         ics_getting_history = H_GOT_UNREQ_HEADER;
2741                         break;
2742                       case EditGame: /*?*/
2743                       case EditPosition: /*?*/
2744                         /* Should above feature work in these modes too? */
2745                         /* For now it doesn't */
2746                         ics_getting_history = H_GOT_UNWANTED_HEADER;
2747                         break;
2748                       default:
2749                         ics_getting_history = H_GOT_UNWANTED_HEADER;
2750                         break;
2751                     }
2752                     break;
2753                   case H_REQUESTED:
2754                     /* Is this the right one? */
2755                     if (gameInfo.white && gameInfo.black &&
2756                         strcmp(gameInfo.white, star_match[0]) == 0 &&
2757                         strcmp(gameInfo.black, star_match[2]) == 0) {
2758                         /* All is well */
2759                         ics_getting_history = H_GOT_REQ_HEADER;
2760                     }
2761                     break;
2762                   case H_GOT_REQ_HEADER:
2763                   case H_GOT_UNREQ_HEADER:
2764                   case H_GOT_UNWANTED_HEADER:
2765                   case H_GETTING_MOVES:
2766                     /* Should not happen */
2767                     DisplayError(_("Error gathering move list: two headers"), 0);
2768                     ics_getting_history = H_FALSE;
2769                     break;
2770                 }
2771
2772                 /* Save player ratings into gameInfo if needed */
2773                 if ((ics_getting_history == H_GOT_REQ_HEADER ||
2774                      ics_getting_history == H_GOT_UNREQ_HEADER) &&
2775                     (gameInfo.whiteRating == -1 ||
2776                      gameInfo.blackRating == -1)) {
2777
2778                     gameInfo.whiteRating = string_to_rating(star_match[1]);
2779                     gameInfo.blackRating = string_to_rating(star_match[3]);
2780                     if (appData.debugMode)
2781                       fprintf(debugFP, _("Ratings from header: W %d, B %d\n"),
2782                               gameInfo.whiteRating, gameInfo.blackRating);
2783                 }
2784                 continue;
2785             }
2786
2787             if (looking_at(buf, &i,
2788               "* * match, initial time: * minute*, increment: * second")) {
2789                 /* Header for a move list -- second line */
2790                 /* Initial board will follow if this is a wild game */
2791                 if (gameInfo.event != NULL) free(gameInfo.event);
2792                 sprintf(str, "ICS %s %s match", star_match[0], star_match[1]);
2793                 gameInfo.event = StrSave(str);
2794                 /* [HGM] we switched variant. Translate boards if needed. */
2795                 VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event));
2796                 continue;
2797             }
2798
2799             if (looking_at(buf, &i, "Move  ")) {
2800                 /* Beginning of a move list */
2801                 switch (ics_getting_history) {
2802                   case H_FALSE:
2803                     /* Normally should not happen */
2804                     /* Maybe user hit reset while we were parsing */
2805                     break;
2806                   case H_REQUESTED:
2807                     /* Happens if we are ignoring a move list that is not
2808                      * the one we just requested.  Common if the user
2809                      * tries to observe two games without turning off
2810                      * getMoveList */
2811                     break;
2812                   case H_GETTING_MOVES:
2813                     /* Should not happen */
2814                     DisplayError(_("Error gathering move list: nested"), 0);
2815                     ics_getting_history = H_FALSE;
2816                     break;
2817                   case H_GOT_REQ_HEADER:
2818                     ics_getting_history = H_GETTING_MOVES;
2819                     started = STARTED_MOVES;
2820                     parse_pos = 0;
2821                     if (oldi > next_out) {
2822                         SendToPlayer(&buf[next_out], oldi - next_out);
2823                     }
2824                     break;
2825                   case H_GOT_UNREQ_HEADER:
2826                     ics_getting_history = H_GETTING_MOVES;
2827                     started = STARTED_MOVES_NOHIDE;
2828                     parse_pos = 0;
2829                     break;
2830                   case H_GOT_UNWANTED_HEADER:
2831                     ics_getting_history = H_FALSE;
2832                     break;
2833                 }
2834                 continue;
2835             }
2836
2837             if (looking_at(buf, &i, "% ") ||
2838                 ((started == STARTED_MOVES || started == STARTED_MOVES_NOHIDE)
2839                  && looking_at(buf, &i, "}*"))) { char *bookHit = NULL; // [HGM] book
2840                 savingComment = FALSE;
2841                 switch (started) {
2842                   case STARTED_MOVES:
2843                   case STARTED_MOVES_NOHIDE:
2844                     memcpy(&parse[parse_pos], &buf[oldi], i - oldi);
2845                     parse[parse_pos + i - oldi] = NULLCHAR;
2846                     ParseGameHistory(parse);
2847 #if ZIPPY
2848                     if (appData.zippyPlay && first.initDone) {
2849                         FeedMovesToProgram(&first, forwardMostMove);
2850                         if (gameMode == IcsPlayingWhite) {
2851                             if (WhiteOnMove(forwardMostMove)) {
2852                                 if (first.sendTime) {
2853                                   if (first.useColors) {
2854                                     SendToProgram("black\n", &first);
2855                                   }
2856                                   SendTimeRemaining(&first, TRUE);
2857                                 }
2858                                 if (first.useColors) {
2859                                   SendToProgram("white\n", &first); // [HGM] book: made sending of "go\n" book dependent
2860                                 }
2861                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: probe book for initial pos
2862                                 first.maybeThinking = TRUE;
2863                             } else {
2864                                 if (first.usePlayother) {
2865                                   if (first.sendTime) {
2866                                     SendTimeRemaining(&first, TRUE);
2867                                   }
2868                                   SendToProgram("playother\n", &first);
2869                                   firstMove = FALSE;
2870                                 } else {
2871                                   firstMove = TRUE;
2872                                 }
2873                             }
2874                         } else if (gameMode == IcsPlayingBlack) {
2875                             if (!WhiteOnMove(forwardMostMove)) {
2876                                 if (first.sendTime) {
2877                                   if (first.useColors) {
2878                                     SendToProgram("white\n", &first);
2879                                   }
2880                                   SendTimeRemaining(&first, FALSE);
2881                                 }
2882                                 if (first.useColors) {
2883                                   SendToProgram("black\n", &first);
2884                                 }
2885                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE);
2886                                 first.maybeThinking = TRUE;
2887                             } else {
2888                                 if (first.usePlayother) {
2889                                   if (first.sendTime) {
2890                                     SendTimeRemaining(&first, FALSE);
2891                                   }
2892                                   SendToProgram("playother\n", &first);
2893                                   firstMove = FALSE;
2894                                 } else {
2895                                   firstMove = TRUE;
2896                                 }
2897                             }
2898                         }
2899                     }
2900 #endif
2901                     if (gameMode == IcsObserving && ics_gamenum == -1) {
2902                         /* Moves came from oldmoves or moves command
2903                            while we weren't doing anything else.
2904                            */
2905                         currentMove = forwardMostMove;
2906                         ClearHighlights();/*!!could figure this out*/
2907                         flipView = appData.flipView;
2908                         DrawPosition(TRUE, boards[currentMove]);
2909                         DisplayBothClocks();
2910                         sprintf(str, "%s vs. %s",
2911                                 gameInfo.white, gameInfo.black);
2912                         DisplayTitle(str);
2913                         gameMode = IcsIdle;
2914                     } else {
2915                         /* Moves were history of an active game */
2916                         if (gameInfo.resultDetails != NULL) {
2917                             free(gameInfo.resultDetails);
2918                             gameInfo.resultDetails = NULL;
2919                         }
2920                     }
2921                     HistorySet(parseList, backwardMostMove,
2922                                forwardMostMove, currentMove-1);
2923                     DisplayMove(currentMove - 1);
2924                     if (started == STARTED_MOVES) next_out = i;
2925                     started = STARTED_NONE;
2926                     ics_getting_history = H_FALSE;
2927                     break;
2928
2929                   case STARTED_OBSERVE:
2930                     started = STARTED_NONE;
2931                     SendToICS(ics_prefix);
2932                     SendToICS("refresh\n");
2933                     break;
2934
2935                   default:
2936                     break;
2937                 }
2938                 if(bookHit) { // [HGM] book: simulate book reply
2939                     static char bookMove[MSG_SIZ]; // a bit generous?
2940
2941                     programStats.nodes = programStats.depth = programStats.time =
2942                     programStats.score = programStats.got_only_move = 0;
2943                     sprintf(programStats.movelist, "%s (xbook)", bookHit);
2944
2945                     strcpy(bookMove, "move ");
2946                     strcat(bookMove, bookHit);
2947                     HandleMachineMove(bookMove, &first);
2948                 }
2949                 continue;
2950             }
2951
2952             if ((started == STARTED_MOVES || started == STARTED_BOARD ||
2953                  started == STARTED_HOLDINGS ||
2954                  started == STARTED_MOVES_NOHIDE) && i >= leftover_len) {
2955                 /* Accumulate characters in move list or board */
2956                 parse[parse_pos++] = buf[i];
2957             }
2958
2959             /* Start of game messages.  Mostly we detect start of game
2960                when the first board image arrives.  On some versions
2961                of the ICS, though, we need to do a "refresh" after starting
2962                to observe in order to get the current board right away. */
2963             if (looking_at(buf, &i, "Adding game * to observation list")) {
2964                 started = STARTED_OBSERVE;
2965                 continue;
2966             }
2967
2968             /* Handle auto-observe */
2969             if (appData.autoObserve &&
2970                 (gameMode == IcsIdle || gameMode == BeginningOfGame) &&
2971                 looking_at(buf, &i, "Game notification: * (*) vs. * (*)")) {
2972                 char *player;
2973                 /* Choose the player that was highlighted, if any. */
2974                 if (star_match[0][0] == '\033' ||
2975                     star_match[1][0] != '\033') {
2976                     player = star_match[0];
2977                 } else {
2978                     player = star_match[2];
2979                 }
2980                 sprintf(str, "%sobserve %s\n",
2981                         ics_prefix, StripHighlightAndTitle(player));
2982                 SendToICS(str);
2983
2984                 /* Save ratings from notify string */
2985                 strcpy(player1Name, star_match[0]);
2986                 player1Rating = string_to_rating(star_match[1]);
2987                 strcpy(player2Name, star_match[2]);
2988                 player2Rating = string_to_rating(star_match[3]);
2989
2990                 if (appData.debugMode)
2991                   fprintf(debugFP,
2992                           "Ratings from 'Game notification:' %s %d, %s %d\n",
2993                           player1Name, player1Rating,
2994                           player2Name, player2Rating);
2995
2996                 continue;
2997             }
2998
2999             /* Deal with automatic examine mode after a game,
3000                and with IcsObserving -> IcsExamining transition */
3001             if (looking_at(buf, &i, "Entering examine mode for game *") ||
3002                 looking_at(buf, &i, "has made you an examiner of game *")) {
3003
3004                 int gamenum = atoi(star_match[0]);
3005                 if ((gameMode == IcsIdle || gameMode == IcsObserving) &&
3006                     gamenum == ics_gamenum) {
3007                     /* We were already playing or observing this game;
3008                        no need to refetch history */
3009                     gameMode = IcsExamining;
3010                     if (pausing) {
3011                         pauseExamForwardMostMove = forwardMostMove;
3012                     } else if (currentMove < forwardMostMove) {
3013                         ForwardInner(forwardMostMove);
3014                     }
3015                 } else {
3016                     /* I don't think this case really can happen */
3017                     SendToICS(ics_prefix);
3018                     SendToICS("refresh\n");
3019                 }
3020                 continue;
3021             }
3022
3023             /* Error messages */
3024 //          if (ics_user_moved) {
3025             if (1) { // [HGM] old way ignored error after move type in; ics_user_moved is not set then!
3026                 if (looking_at(buf, &i, "Illegal move") ||
3027                     looking_at(buf, &i, "Not a legal move") ||
3028                     looking_at(buf, &i, "Your king is in check") ||
3029                     looking_at(buf, &i, "It isn't your turn") ||
3030                     looking_at(buf, &i, "It is not your move")) {
3031                     /* Illegal move */
3032                     if (ics_user_moved && forwardMostMove > backwardMostMove) { // only backup if we already moved
3033                         currentMove = --forwardMostMove;
3034                         DisplayMove(currentMove - 1); /* before DMError */
3035                         DrawPosition(FALSE, boards[currentMove]);
3036                         SwitchClocks();
3037                         DisplayBothClocks();
3038                     }
3039                     DisplayMoveError(_("Illegal move (rejected by ICS)")); // [HGM] but always relay error msg
3040                     ics_user_moved = 0;
3041                     continue;
3042                 }
3043             }
3044
3045             if (looking_at(buf, &i, "still have time") ||
3046                 looking_at(buf, &i, "not out of time") ||
3047                 looking_at(buf, &i, "either player is out of time") ||
3048                 looking_at(buf, &i, "has timeseal; checking")) {
3049                 /* We must have called his flag a little too soon */
3050                 whiteFlag = blackFlag = FALSE;
3051                 continue;
3052             }
3053
3054             if (looking_at(buf, &i, "added * seconds to") ||
3055                 looking_at(buf, &i, "seconds were added to")) {
3056                 /* Update the clocks */
3057                 SendToICS(ics_prefix);
3058                 SendToICS("refresh\n");
3059                 continue;
3060             }
3061
3062             if (!ics_clock_paused && looking_at(buf, &i, "clock paused")) {
3063                 ics_clock_paused = TRUE;
3064                 StopClocks();
3065                 continue;
3066             }
3067
3068             if (ics_clock_paused && looking_at(buf, &i, "clock resumed")) {
3069                 ics_clock_paused = FALSE;
3070                 StartClocks();
3071                 continue;
3072             }
3073
3074             /* Grab player ratings from the Creating: message.
3075                Note we have to check for the special case when
3076                the ICS inserts things like [white] or [black]. */
3077             if (looking_at(buf, &i, "Creating: * (*)* * (*)") ||
3078                 looking_at(buf, &i, "Creating: * (*) [*] * (*)")) {
3079                 /* star_matches:
3080                    0    player 1 name (not necessarily white)
3081                    1    player 1 rating
3082                    2    empty, white, or black (IGNORED)
3083                    3    player 2 name (not necessarily black)
3084                    4    player 2 rating
3085
3086                    The names/ratings are sorted out when the game
3087                    actually starts (below).
3088                 */
3089                 strcpy(player1Name, StripHighlightAndTitle(star_match[0]));
3090                 player1Rating = string_to_rating(star_match[1]);
3091                 strcpy(player2Name, StripHighlightAndTitle(star_match[3]));
3092                 player2Rating = string_to_rating(star_match[4]);
3093
3094                 if (appData.debugMode)
3095                   fprintf(debugFP,
3096                           "Ratings from 'Creating:' %s %d, %s %d\n",
3097                           player1Name, player1Rating,
3098                           player2Name, player2Rating);
3099
3100                 continue;
3101             }
3102
3103             /* Improved generic start/end-of-game messages */
3104             if ((tkind=0, looking_at(buf, &i, "{Game * (* vs. *) *}*")) ||
3105                 (tkind=1, looking_at(buf, &i, "{Game * (*(*) vs. *(*)) *}*"))){
3106                 /* If tkind == 0: */
3107                 /* star_match[0] is the game number */
3108                 /*           [1] is the white player's name */
3109                 /*           [2] is the black player's name */
3110                 /* For end-of-game: */
3111                 /*           [3] is the reason for the game end */
3112                 /*           [4] is a PGN end game-token, preceded by " " */
3113                 /* For start-of-game: */
3114                 /*           [3] begins with "Creating" or "Continuing" */
3115                 /*           [4] is " *" or empty (don't care). */
3116                 int gamenum = atoi(star_match[0]);
3117                 char *whitename, *blackname, *why, *endtoken;
3118                 ChessMove endtype = (ChessMove) 0;
3119
3120                 if (tkind == 0) {
3121                   whitename = star_match[1];
3122                   blackname = star_match[2];
3123                   why = star_match[3];
3124                   endtoken = star_match[4];
3125                 } else {
3126                   whitename = star_match[1];
3127                   blackname = star_match[3];
3128                   why = star_match[5];
3129                   endtoken = star_match[6];
3130                 }
3131
3132                 /* Game start messages */
3133                 if (strncmp(why, "Creating ", 9) == 0 ||
3134                     strncmp(why, "Continuing ", 11) == 0) {
3135                     gs_gamenum = gamenum;
3136                     strcpy(gs_kind, strchr(why, ' ') + 1);
3137 #if ZIPPY
3138                     if (appData.zippyPlay) {
3139                         ZippyGameStart(whitename, blackname);
3140                     }
3141 #endif /*ZIPPY*/
3142                     continue;
3143                 }
3144
3145                 /* Game end messages */
3146                 if (gameMode == IcsIdle || gameMode == BeginningOfGame ||
3147                     ics_gamenum != gamenum) {
3148                     continue;
3149                 }
3150                 while (endtoken[0] == ' ') endtoken++;
3151                 switch (endtoken[0]) {
3152                   case '*':
3153                   default:
3154                     endtype = GameUnfinished;
3155                     break;
3156                   case '0':
3157                     endtype = BlackWins;
3158                     break;
3159                   case '1':
3160                     if (endtoken[1] == '/')
3161                       endtype = GameIsDrawn;
3162                     else
3163                       endtype = WhiteWins;
3164                     break;
3165                 }
3166                 GameEnds(endtype, why, GE_ICS);
3167 #if ZIPPY
3168                 if (appData.zippyPlay && first.initDone) {
3169                     ZippyGameEnd(endtype, why);
3170                     if (first.pr == NULL) {
3171                       /* Start the next process early so that we'll
3172                          be ready for the next challenge */
3173                       StartChessProgram(&first);
3174                     }
3175                     /* Send "new" early, in case this command takes
3176                        a long time to finish, so that we'll be ready
3177                        for the next challenge. */
3178                     gameInfo.variant = VariantNormal; // [HGM] variantswitch: suppress sending of 'variant'
3179                     Reset(TRUE, TRUE);
3180                 }
3181 #endif /*ZIPPY*/
3182                 continue;
3183             }
3184
3185             if (looking_at(buf, &i, "Removing game * from observation") ||
3186                 looking_at(buf, &i, "no longer observing game *") ||
3187                 looking_at(buf, &i, "Game * (*) has no examiners")) {
3188                 if (gameMode == IcsObserving &&
3189                     atoi(star_match[0]) == ics_gamenum)
3190                   {
3191                       /* icsEngineAnalyze */
3192                       if (appData.icsEngineAnalyze) {
3193                             ExitAnalyzeMode();
3194                             ModeHighlight();
3195                       }
3196                       StopClocks();
3197                       gameMode = IcsIdle;
3198                       ics_gamenum = -1;
3199                       ics_user_moved = FALSE;
3200                   }
3201                 continue;
3202             }
3203
3204             if (looking_at(buf, &i, "no longer examining game *")) {
3205                 if (gameMode == IcsExamining &&
3206                     atoi(star_match[0]) == ics_gamenum)
3207                   {
3208                       gameMode = IcsIdle;
3209                       ics_gamenum = -1;
3210                       ics_user_moved = FALSE;
3211                   }
3212                 continue;
3213             }
3214
3215             /* Advance leftover_start past any newlines we find,
3216                so only partial lines can get reparsed */
3217             if (looking_at(buf, &i, "\n")) {
3218                 prevColor = curColor;
3219                 if (curColor != ColorNormal) {
3220                     if (oldi > next_out) {
3221                         SendToPlayer(&buf[next_out], oldi - next_out);
3222                         next_out = oldi;
3223                     }
3224                     Colorize(ColorNormal, FALSE);
3225                     curColor = ColorNormal;
3226                 }
3227                 if (started == STARTED_BOARD) {
3228                     started = STARTED_NONE;
3229                     parse[parse_pos] = NULLCHAR;
3230                     ParseBoard12(parse);
3231                     ics_user_moved = 0;
3232
3233                     /* Send premove here */
3234                     if (appData.premove) {
3235                       char str[MSG_SIZ];
3236                       if (currentMove == 0 &&
3237                           gameMode == IcsPlayingWhite &&
3238                           appData.premoveWhite) {
3239                         sprintf(str, "%s\n", appData.premoveWhiteText);
3240                         if (appData.debugMode)
3241                           fprintf(debugFP, "Sending premove:\n");
3242                         SendToICS(str);
3243                       } else if (currentMove == 1 &&
3244                                  gameMode == IcsPlayingBlack &&
3245                                  appData.premoveBlack) {
3246                         sprintf(str, "%s\n", appData.premoveBlackText);
3247                         if (appData.debugMode)
3248                           fprintf(debugFP, "Sending premove:\n");
3249                         SendToICS(str);
3250                       } else if (gotPremove) {
3251                         gotPremove = 0;
3252                         ClearPremoveHighlights();
3253                         if (appData.debugMode)
3254                           fprintf(debugFP, "Sending premove:\n");
3255                           UserMoveEvent(premoveFromX, premoveFromY,
3256                                         premoveToX, premoveToY,
3257                                         premovePromoChar);
3258                       }
3259                     }
3260
3261                     /* Usually suppress following prompt */
3262                     if (!(forwardMostMove == 0 && gameMode == IcsExamining)) {
3263                         while(looking_at(buf, &i, "\n")); // [HGM] skip empty lines
3264                         if (looking_at(buf, &i, "*% ")) {
3265                             savingComment = FALSE;
3266                         }
3267                     }
3268                     next_out = i;
3269                 } else if (started == STARTED_HOLDINGS) {
3270                     int gamenum;
3271                     char new_piece[MSG_SIZ];
3272                     started = STARTED_NONE;
3273                     parse[parse_pos] = NULLCHAR;
3274                     if (appData.debugMode)
3275                       fprintf(debugFP, "Parsing holdings: %s, currentMove = %d\n",
3276                                                         parse, currentMove);
3277                     if (sscanf(parse, " game %d", &gamenum) == 1 &&
3278                         gamenum == ics_gamenum) {
3279                         if (gameInfo.variant == VariantNormal) {
3280                           /* [HGM] We seem to switch variant during a game!
3281                            * Presumably no holdings were displayed, so we have
3282                            * to move the position two files to the right to
3283                            * create room for them!
3284                            */
3285                           VariantClass newVariant;
3286                           switch(gameInfo.boardWidth) { // base guess on board width
3287                                 case 9:  newVariant = VariantShogi; break;
3288                                 case 10: newVariant = VariantGreat; break;
3289                                 default: newVariant = VariantCrazyhouse; break;
3290                           }
3291                           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
3292                           /* Get a move list just to see the header, which
3293                              will tell us whether this is really bug or zh */
3294                           if (ics_getting_history == H_FALSE) {
3295                             ics_getting_history = H_REQUESTED;
3296                             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3297                             SendToICS(str);
3298                           }
3299                         }
3300                         new_piece[0] = NULLCHAR;
3301                         sscanf(parse, "game %d white [%s black [%s <- %s",
3302                                &gamenum, white_holding, black_holding,
3303                                new_piece);
3304                         white_holding[strlen(white_holding)-1] = NULLCHAR;
3305                         black_holding[strlen(black_holding)-1] = NULLCHAR;
3306                         /* [HGM] copy holdings to board holdings area */
3307                         CopyHoldings(boards[forwardMostMove], white_holding, WhitePawn);
3308                         CopyHoldings(boards[forwardMostMove], black_holding, BlackPawn);
3309                         boards[forwardMostMove][BOARD_SIZE-1][BOARD_SIZE-2] = 1; // flag holdings as set
3310 #if ZIPPY
3311                         if (appData.zippyPlay && first.initDone) {
3312                             ZippyHoldings(white_holding, black_holding,
3313                                           new_piece);
3314                         }
3315 #endif /*ZIPPY*/
3316                         if (tinyLayout || smallLayout) {
3317                             char wh[16], bh[16];
3318                             PackHolding(wh, white_holding);
3319                             PackHolding(bh, black_holding);
3320                             sprintf(str, "[%s-%s] %s-%s", wh, bh,
3321                                     gameInfo.white, gameInfo.black);
3322                         } else {
3323                             sprintf(str, "%s [%s] vs. %s [%s]",
3324                                     gameInfo.white, white_holding,
3325                                     gameInfo.black, black_holding);
3326                         }
3327
3328                         DrawPosition(FALSE, boards[currentMove]);
3329                         DisplayTitle(str);
3330                     }
3331                     /* Suppress following prompt */
3332                     if (looking_at(buf, &i, "*% ")) {
3333                         if(strchr(star_match[0], 7)) SendToPlayer("\007", 1); // Bell(); // FICS fuses bell for next board with prompt in zh captures
3334                         savingComment = FALSE;
3335                     }
3336                     next_out = i;
3337                 }
3338                 continue;
3339             }
3340
3341             i++;                /* skip unparsed character and loop back */
3342         }
3343
3344         if (started != STARTED_MOVES && started != STARTED_BOARD && !suppressKibitz && // [HGM] kibitz suppress printing in ICS interaction window
3345             started != STARTED_HOLDINGS && i > next_out) {
3346             SendToPlayer(&buf[next_out], i - next_out);
3347             next_out = i;
3348         }
3349         suppressKibitz = FALSE; // [HGM] kibitz: has done its duty in if-statement above
3350
3351         leftover_len = buf_len - leftover_start;
3352         /* if buffer ends with something we couldn't parse,
3353            reparse it after appending the next read */
3354
3355     } else if (count == 0) {
3356         RemoveInputSource(isr);
3357         DisplayFatalError(_("Connection closed by ICS"), 0, 0);
3358     } else {
3359         DisplayFatalError(_("Error reading from ICS"), error, 1);
3360     }
3361 }
3362
3363
3364 /* Board style 12 looks like this:
3365
3366    <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
3367
3368  * The "<12> " is stripped before it gets to this routine.  The two
3369  * trailing 0's (flip state and clock ticking) are later addition, and
3370  * some chess servers may not have them, or may have only the first.
3371  * Additional trailing fields may be added in the future.
3372  */
3373
3374 #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"
3375
3376 #define RELATION_OBSERVING_PLAYED    0
3377 #define RELATION_OBSERVING_STATIC   -2   /* examined, oldmoves, or smoves */
3378 #define RELATION_PLAYING_MYMOVE      1
3379 #define RELATION_PLAYING_NOTMYMOVE  -1
3380 #define RELATION_EXAMINING           2
3381 #define RELATION_ISOLATED_BOARD     -3
3382 #define RELATION_STARTING_POSITION  -4   /* FICS only */
3383
3384 void
3385 ParseBoard12(string)
3386      char *string;
3387 {
3388     GameMode newGameMode;
3389     int gamenum, newGame, newMove, relation, basetime, increment, ics_flip = 0, i;
3390     int j, k, n, moveNum, white_stren, black_stren, white_time, black_time, takeback;
3391     int double_push, castle_ws, castle_wl, castle_bs, castle_bl, irrev_count;
3392     char to_play, board_chars[200];
3393     char move_str[500], str[500], elapsed_time[500];
3394     char black[32], white[32];
3395     Board board;
3396     int prevMove = currentMove;
3397     int ticking = 2;
3398     ChessMove moveType;
3399     int fromX, fromY, toX, toY;
3400     char promoChar;
3401     int ranks=1, files=0; /* [HGM] ICS80: allow variable board size */
3402     char *bookHit = NULL; // [HGM] book
3403     Boolean weird = FALSE, reqFlag = FALSE;
3404
3405     fromX = fromY = toX = toY = -1;
3406
3407     newGame = FALSE;
3408
3409     if (appData.debugMode)
3410       fprintf(debugFP, _("Parsing board: %s\n"), string);
3411
3412     move_str[0] = NULLCHAR;
3413     elapsed_time[0] = NULLCHAR;
3414     {   /* [HGM] figure out how many ranks and files the board has, for ICS extension used by Capablanca server */
3415         int  i = 0, j;
3416         while(i < 199 && (string[i] != ' ' || string[i+2] != ' ')) {
3417             if(string[i] == ' ') { ranks++; files = 0; }
3418             else files++;
3419             if(!strchr(" -pnbrqkPNBRQK" , string[i])) weird = TRUE; // test for fairies
3420             i++;
3421         }
3422         for(j = 0; j <i; j++) board_chars[j] = string[j];
3423         board_chars[i] = '\0';
3424         string += i + 1;
3425     }
3426     n = sscanf(string, PATTERN, &to_play, &double_push,
3427                &castle_ws, &castle_wl, &castle_bs, &castle_bl, &irrev_count,
3428                &gamenum, white, black, &relation, &basetime, &increment,
3429                &white_stren, &black_stren, &white_time, &black_time,
3430                &moveNum, str, elapsed_time, move_str, &ics_flip,
3431                &ticking);
3432
3433     if (n < 21) {
3434         snprintf(str, sizeof(str), _("Failed to parse board string:\n\"%s\""), string);
3435         DisplayError(str, 0);
3436         return;
3437     }
3438
3439     /* Convert the move number to internal form */
3440     moveNum = (moveNum - 1) * 2;
3441     if (to_play == 'B') moveNum++;
3442     if (moveNum >= MAX_MOVES) {
3443       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
3444                         0, 1);
3445       return;
3446     }
3447
3448     switch (relation) {
3449       case RELATION_OBSERVING_PLAYED:
3450       case RELATION_OBSERVING_STATIC:
3451         if (gamenum == -1) {
3452             /* Old ICC buglet */
3453             relation = RELATION_OBSERVING_STATIC;
3454         }
3455         newGameMode = IcsObserving;
3456         break;
3457       case RELATION_PLAYING_MYMOVE:
3458       case RELATION_PLAYING_NOTMYMOVE:
3459         newGameMode =
3460           ((relation == RELATION_PLAYING_MYMOVE) == (to_play == 'W')) ?
3461             IcsPlayingWhite : IcsPlayingBlack;
3462         break;
3463       case RELATION_EXAMINING:
3464         newGameMode = IcsExamining;
3465         break;
3466       case RELATION_ISOLATED_BOARD:
3467       default:
3468         /* Just display this board.  If user was doing something else,
3469            we will forget about it until the next board comes. */
3470         newGameMode = IcsIdle;
3471         break;
3472       case RELATION_STARTING_POSITION:
3473         newGameMode = gameMode;
3474         break;
3475     }
3476
3477     /* Modify behavior for initial board display on move listing
3478        of wild games.
3479        */
3480     switch (ics_getting_history) {
3481       case H_FALSE:
3482       case H_REQUESTED:
3483         break;
3484       case H_GOT_REQ_HEADER:
3485       case H_GOT_UNREQ_HEADER:
3486         /* This is the initial position of the current game */
3487         gamenum = ics_gamenum;
3488         moveNum = 0;            /* old ICS bug workaround */
3489         if (to_play == 'B') {
3490           startedFromSetupPosition = TRUE;
3491           blackPlaysFirst = TRUE;
3492           moveNum = 1;
3493           if (forwardMostMove == 0) forwardMostMove = 1;
3494           if (backwardMostMove == 0) backwardMostMove = 1;
3495           if (currentMove == 0) currentMove = 1;
3496         }
3497         newGameMode = gameMode;
3498         relation = RELATION_STARTING_POSITION; /* ICC needs this */
3499         break;
3500       case H_GOT_UNWANTED_HEADER:
3501         /* This is an initial board that we don't want */
3502         return;
3503       case H_GETTING_MOVES:
3504         /* Should not happen */
3505         DisplayError(_("Error gathering move list: extra board"), 0);
3506         ics_getting_history = H_FALSE;
3507         return;
3508     }
3509
3510    if (gameInfo.boardHeight != ranks || gameInfo.boardWidth != files ||
3511                                         weird && (int)gameInfo.variant <= (int)VariantShogi) {
3512      /* [HGM] We seem to have switched variant unexpectedly
3513       * Try to guess new variant from board size
3514       */
3515           VariantClass newVariant = VariantFairy; // if 8x8, but fairies present
3516           if(ranks == 8 && files == 10) newVariant = VariantCapablanca; else
3517           if(ranks == 10 && files == 9) newVariant = VariantXiangqi; else
3518           if(ranks == 8 && files == 12) newVariant = VariantCourier; else
3519           if(ranks == 9 && files == 9)  newVariant = VariantShogi; else
3520           if(!weird) newVariant = VariantNormal;
3521           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
3522           /* Get a move list just to see the header, which
3523              will tell us whether this is really bug or zh */
3524           if (ics_getting_history == H_FALSE) {
3525             ics_getting_history = H_REQUESTED; reqFlag = TRUE;
3526             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3527             SendToICS(str);
3528           }
3529     }
3530
3531     /* Take action if this is the first board of a new game, or of a
3532        different game than is currently being displayed.  */
3533     if (gamenum != ics_gamenum || newGameMode != gameMode ||
3534         relation == RELATION_ISOLATED_BOARD) {
3535
3536         /* Forget the old game and get the history (if any) of the new one */
3537         if (gameMode != BeginningOfGame) {
3538           Reset(TRUE, TRUE);
3539         }
3540         newGame = TRUE;
3541         if (appData.autoRaiseBoard) BoardToTop();
3542         prevMove = -3;
3543         if (gamenum == -1) {
3544             newGameMode = IcsIdle;
3545         } else if ((moveNum > 0 || newGameMode == IcsObserving) && newGameMode != IcsIdle &&
3546                    appData.getMoveList && !reqFlag) {
3547             /* Need to get game history */
3548             ics_getting_history = H_REQUESTED;
3549             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3550             SendToICS(str);
3551         }
3552
3553         /* Initially flip the board to have black on the bottom if playing
3554            black or if the ICS flip flag is set, but let the user change
3555            it with the Flip View button. */
3556         flipView = appData.autoFlipView ?
3557           (newGameMode == IcsPlayingBlack) || ics_flip :
3558           appData.flipView;
3559
3560         /* Done with values from previous mode; copy in new ones */
3561         gameMode = newGameMode;
3562         ModeHighlight();
3563         ics_gamenum = gamenum;
3564         if (gamenum == gs_gamenum) {
3565             int klen = strlen(gs_kind);
3566             if (gs_kind[klen - 1] == '.') gs_kind[klen - 1] = NULLCHAR;
3567             sprintf(str, "ICS %s", gs_kind);
3568             gameInfo.event = StrSave(str);
3569         } else {
3570             gameInfo.event = StrSave("ICS game");
3571         }
3572         gameInfo.site = StrSave(appData.icsHost);
3573         gameInfo.date = PGNDate();
3574         gameInfo.round = StrSave("-");
3575         gameInfo.white = StrSave(white);
3576         gameInfo.black = StrSave(black);
3577         timeControl = basetime * 60 * 1000;
3578         timeControl_2 = 0;
3579         timeIncrement = increment * 1000;
3580         movesPerSession = 0;
3581         gameInfo.timeControl = TimeControlTagValue();
3582         VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event) );
3583   if (appData.debugMode) {
3584     fprintf(debugFP, "ParseBoard says variant = '%s'\n", gameInfo.event);
3585     fprintf(debugFP, "recognized as %s\n", VariantName(gameInfo.variant));
3586     setbuf(debugFP, NULL);
3587   }
3588
3589         gameInfo.outOfBook = NULL;
3590
3591         /* Do we have the ratings? */
3592         if (strcmp(player1Name, white) == 0 &&
3593             strcmp(player2Name, black) == 0) {
3594             if (appData.debugMode)
3595               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
3596                       player1Rating, player2Rating);
3597             gameInfo.whiteRating = player1Rating;
3598             gameInfo.blackRating = player2Rating;
3599         } else if (strcmp(player2Name, white) == 0 &&
3600                    strcmp(player1Name, black) == 0) {
3601             if (appData.debugMode)
3602               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
3603                       player2Rating, player1Rating);
3604             gameInfo.whiteRating = player2Rating;
3605             gameInfo.blackRating = player1Rating;
3606         }
3607         player1Name[0] = player2Name[0] = NULLCHAR;
3608
3609         /* Silence shouts if requested */
3610         if (appData.quietPlay &&
3611             (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)) {
3612             SendToICS(ics_prefix);
3613             SendToICS("set shout 0\n");
3614         }
3615     }
3616
3617     /* Deal with midgame name changes */
3618     if (!newGame) {
3619         if (!gameInfo.white || strcmp(gameInfo.white, white) != 0) {
3620             if (gameInfo.white) free(gameInfo.white);
3621             gameInfo.white = StrSave(white);
3622         }
3623         if (!gameInfo.black || strcmp(gameInfo.black, black) != 0) {
3624             if (gameInfo.black) free(gameInfo.black);
3625             gameInfo.black = StrSave(black);
3626         }
3627     }
3628
3629     /* Throw away game result if anything actually changes in examine mode */
3630     if (gameMode == IcsExamining && !newGame) {
3631         gameInfo.result = GameUnfinished;
3632         if (gameInfo.resultDetails != NULL) {
3633             free(gameInfo.resultDetails);
3634             gameInfo.resultDetails = NULL;
3635         }
3636     }
3637
3638     /* In pausing && IcsExamining mode, we ignore boards coming
3639        in if they are in a different variation than we are. */
3640     if (pauseExamInvalid) return;
3641     if (pausing && gameMode == IcsExamining) {
3642         if (moveNum <= pauseExamForwardMostMove) {
3643             pauseExamInvalid = TRUE;
3644             forwardMostMove = pauseExamForwardMostMove;
3645             return;
3646         }
3647     }
3648
3649   if (appData.debugMode) {
3650     fprintf(debugFP, "load %dx%d board\n", files, ranks);
3651   }
3652     /* Parse the board */
3653     for (k = 0; k < ranks; k++) {
3654       for (j = 0; j < files; j++)
3655         board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
3656       if(gameInfo.holdingsWidth > 1) {
3657            board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
3658            board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
3659       }
3660     }
3661     CopyBoard(boards[moveNum], board);
3662     boards[moveNum][BOARD_SIZE-1][BOARD_SIZE-2] = 0; // [HGM] indicate holdings not set
3663     if (moveNum == 0) {
3664         startedFromSetupPosition =
3665           !CompareBoards(board, initialPosition);
3666         if(startedFromSetupPosition)
3667             initialRulePlies = irrev_count; /* [HGM] 50-move counter offset */
3668     }
3669
3670     /* [HGM] Set castling rights. Take the outermost Rooks,
3671        to make it also work for FRC opening positions. Note that board12
3672        is really defective for later FRC positions, as it has no way to
3673        indicate which Rook can castle if they are on the same side of King.
3674        For the initial position we grant rights to the outermost Rooks,
3675        and remember thos rights, and we then copy them on positions
3676        later in an FRC game. This means WB might not recognize castlings with
3677        Rooks that have moved back to their original position as illegal,
3678        but in ICS mode that is not its job anyway.
3679     */
3680     if(moveNum == 0 || gameInfo.variant != VariantFischeRandom)
3681     { int i, j; ChessSquare wKing = WhiteKing, bKing = BlackKing;
3682
3683         for(i=BOARD_LEFT, j= -1; i<BOARD_RGHT; i++)
3684             if(board[0][i] == WhiteRook) j = i;
3685         initialRights[0] = castlingRights[moveNum][0] = (castle_ws == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3686         for(i=BOARD_RGHT-1, j= -1; i>=BOARD_LEFT; i--)
3687             if(board[0][i] == WhiteRook) j = i;
3688         initialRights[1] = castlingRights[moveNum][1] = (castle_wl == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3689         for(i=BOARD_LEFT, j= -1; i<BOARD_RGHT; i++)
3690             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
3691         initialRights[3] = castlingRights[moveNum][3] = (castle_bs == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3692         for(i=BOARD_RGHT-1, j= -1; i>=BOARD_LEFT; i--)
3693             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
3694         initialRights[4] = castlingRights[moveNum][4] = (castle_bl == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3695
3696         if(gameInfo.variant == VariantKnightmate) { wKing = WhiteUnicorn; bKing = BlackUnicorn; }
3697         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
3698             if(board[0][k] == wKing) initialRights[2] = castlingRights[moveNum][2] = k;
3699         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
3700             if(board[BOARD_HEIGHT-1][k] == bKing)
3701                 initialRights[5] = castlingRights[moveNum][5] = k;
3702     } else { int r;
3703         r = castlingRights[moveNum][0] = initialRights[0];
3704         if(board[0][r] != WhiteRook) castlingRights[moveNum][0] = -1;
3705         r = castlingRights[moveNum][1] = initialRights[1];
3706         if(board[0][r] != WhiteRook) castlingRights[moveNum][1] = -1;
3707         r = castlingRights[moveNum][3] = initialRights[3];
3708         if(board[BOARD_HEIGHT-1][r] != BlackRook) castlingRights[moveNum][3] = -1;
3709         r = castlingRights[moveNum][4] = initialRights[4];
3710         if(board[BOARD_HEIGHT-1][r] != BlackRook) castlingRights[moveNum][4] = -1;
3711         /* wildcastle kludge: always assume King has rights */
3712         r = castlingRights[moveNum][2] = initialRights[2];
3713         r = castlingRights[moveNum][5] = initialRights[5];
3714     }
3715     /* [HGM] e.p. rights. Assume that ICS sends file number here? */
3716     epStatus[moveNum] = double_push == -1 ? EP_NONE : double_push + BOARD_LEFT;
3717
3718
3719     if (ics_getting_history == H_GOT_REQ_HEADER ||
3720         ics_getting_history == H_GOT_UNREQ_HEADER) {
3721         /* This was an initial position from a move list, not
3722            the current position */
3723         return;
3724     }
3725
3726     /* Update currentMove and known move number limits */
3727     newMove = newGame || moveNum > forwardMostMove;
3728
3729     if (newGame) {
3730         forwardMostMove = backwardMostMove = currentMove = moveNum;
3731         if (gameMode == IcsExamining && moveNum == 0) {
3732           /* Workaround for ICS limitation: we are not told the wild
3733              type when starting to examine a game.  But if we ask for
3734              the move list, the move list header will tell us */
3735             ics_getting_history = H_REQUESTED;
3736             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3737             SendToICS(str);
3738         }
3739     } else if (moveNum == forwardMostMove + 1 || moveNum == forwardMostMove
3740                || (moveNum < forwardMostMove && moveNum >= backwardMostMove)) {
3741 #if ZIPPY
3742         /* [DM] If we found takebacks during icsEngineAnalyze try send to engine */
3743         /* [HGM] applied this also to an engine that is silently watching        */
3744         if (appData.zippyPlay && moveNum < forwardMostMove && first.initDone &&
3745             (gameMode == IcsObserving || gameMode == IcsExamining) &&
3746             gameInfo.variant == currentlyInitializedVariant) {
3747           takeback = forwardMostMove - moveNum;
3748           for (i = 0; i < takeback; i++) {
3749             if (appData.debugMode) fprintf(debugFP, "take back move\n");
3750             SendToProgram("undo\n", &first);
3751           }
3752         }
3753 #endif
3754
3755         forwardMostMove = moveNum;
3756         if (!pausing || currentMove > forwardMostMove)
3757           currentMove = forwardMostMove;
3758     } else {
3759         /* New part of history that is not contiguous with old part */
3760         if (pausing && gameMode == IcsExamining) {
3761             pauseExamInvalid = TRUE;
3762             forwardMostMove = pauseExamForwardMostMove;
3763             return;
3764         }
3765         if (gameMode == IcsExamining && moveNum > 0 && appData.getMoveList) {
3766 #if ZIPPY
3767             if(appData.zippyPlay && forwardMostMove > 0 && first.initDone) {
3768                 // [HGM] when we will receive the move list we now request, it will be
3769                 // fed to the engine from the first move on. So if the engine is not
3770                 // in the initial position now, bring it there.
3771                 InitChessProgram(&first, 0);
3772             }
3773 #endif
3774             ics_getting_history = H_REQUESTED;
3775             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3776             SendToICS(str);
3777         }
3778         forwardMostMove = backwardMostMove = currentMove = moveNum;
3779     }
3780
3781     /* Update the clocks */
3782     if (strchr(elapsed_time, '.')) {
3783       /* Time is in ms */
3784       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time;
3785       timeRemaining[1][moveNum] = blackTimeRemaining = black_time;
3786     } else {
3787       /* Time is in seconds */
3788       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time * 1000;
3789       timeRemaining[1][moveNum] = blackTimeRemaining = black_time * 1000;
3790     }
3791
3792
3793 #if ZIPPY
3794     if (appData.zippyPlay && newGame &&
3795         gameMode != IcsObserving && gameMode != IcsIdle &&
3796         gameMode != IcsExamining)
3797       ZippyFirstBoard(moveNum, basetime, increment);
3798 #endif
3799
3800     /* Put the move on the move list, first converting
3801        to canonical algebraic form. */
3802     if (moveNum > 0) {
3803   if (appData.debugMode) {
3804     if (appData.debugMode) { int f = forwardMostMove;
3805         fprintf(debugFP, "parseboard %d, castling = %d %d %d %d %d %d\n", f,
3806                 castlingRights[f][0],castlingRights[f][1],castlingRights[f][2],castlingRights[f][3],castlingRights[f][4],castlingRights[f][5]);
3807     }
3808     fprintf(debugFP, "accepted move %s from ICS, parse it.\n", move_str);
3809     fprintf(debugFP, "moveNum = %d\n", moveNum);
3810     fprintf(debugFP, "board = %d-%d x %d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT);
3811     setbuf(debugFP, NULL);
3812   }
3813         if (moveNum <= backwardMostMove) {
3814             /* We don't know what the board looked like before
3815                this move.  Punt. */
3816             strcpy(parseList[moveNum - 1], move_str);
3817             strcat(parseList[moveNum - 1], " ");
3818             strcat(parseList[moveNum - 1], elapsed_time);
3819             moveList[moveNum - 1][0] = NULLCHAR;
3820         } else if (strcmp(move_str, "none") == 0) {
3821             // [HGM] long SAN: swapped order; test for 'none' before parsing move
3822             /* Again, we don't know what the board looked like;
3823                this is really the start of the game. */
3824             parseList[moveNum - 1][0] = NULLCHAR;
3825             moveList[moveNum - 1][0] = NULLCHAR;
3826             backwardMostMove = moveNum;
3827             startedFromSetupPosition = TRUE;
3828             fromX = fromY = toX = toY = -1;
3829         } else {
3830           // [HGM] long SAN: if legality-testing is off, disambiguation might not work or give wrong move.
3831           //                 So we parse the long-algebraic move string in stead of the SAN move
3832           int valid; char buf[MSG_SIZ], *prom;
3833
3834           // str looks something like "Q/a1-a2"; kill the slash
3835           if(str[1] == '/')
3836                 sprintf(buf, "%c%s", str[0], str+2);
3837           else  strcpy(buf, str); // might be castling
3838           if((prom = strstr(move_str, "=")) && !strstr(buf, "="))
3839                 strcat(buf, prom); // long move lacks promo specification!
3840           if(!appData.testLegality && move_str[1] != '@') { // drops never ambiguous (parser chokes on long form!)
3841                 if(appData.debugMode)
3842                         fprintf(debugFP, "replaced ICS move '%s' by '%s'\n", move_str, buf);
3843                 strcpy(move_str, buf);
3844           }
3845           valid = ParseOneMove(move_str, moveNum - 1, &moveType,
3846                                 &fromX, &fromY, &toX, &toY, &promoChar)
3847                || ParseOneMove(buf, moveNum - 1, &moveType,
3848                                 &fromX, &fromY, &toX, &toY, &promoChar);
3849           // end of long SAN patch
3850           if (valid) {
3851             (void) CoordsToAlgebraic(boards[moveNum - 1],
3852                                      PosFlags(moveNum - 1), EP_UNKNOWN,
3853                                      fromY, fromX, toY, toX, promoChar,
3854                                      parseList[moveNum-1]);
3855             switch (MateTest(boards[moveNum], PosFlags(moveNum), EP_UNKNOWN,
3856                              castlingRights[moveNum]) ) {
3857               case MT_NONE:
3858               case MT_STALEMATE:
3859               default:
3860                 break;
3861               case MT_CHECK:
3862                 if(gameInfo.variant != VariantShogi)
3863                     strcat(parseList[moveNum - 1], "+");
3864                 break;
3865               case MT_CHECKMATE:
3866               case MT_STAINMATE: // [HGM] xq: for notation stalemate that wins counts as checkmate
3867                 strcat(parseList[moveNum - 1], "#");
3868                 break;
3869             }
3870             strcat(parseList[moveNum - 1], " ");
3871             strcat(parseList[moveNum - 1], elapsed_time);
3872             /* currentMoveString is set as a side-effect of ParseOneMove */
3873             strcpy(moveList[moveNum - 1], currentMoveString);
3874             strcat(moveList[moveNum - 1], "\n");
3875           } else {
3876             /* Move from ICS was illegal!?  Punt. */
3877   if (appData.debugMode) {
3878     fprintf(debugFP, "Illegal move from ICS '%s'\n", move_str);
3879     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
3880   }
3881             strcpy(parseList[moveNum - 1], move_str);
3882             strcat(parseList[moveNum - 1], " ");
3883             strcat(parseList[moveNum - 1], elapsed_time);
3884             moveList[moveNum - 1][0] = NULLCHAR;
3885             fromX = fromY = toX = toY = -1;
3886           }
3887         }
3888   if (appData.debugMode) {
3889     fprintf(debugFP, "Move parsed to '%s'\n", parseList[moveNum - 1]);
3890     setbuf(debugFP, NULL);
3891   }
3892
3893 #if ZIPPY
3894         /* Send move to chess program (BEFORE animating it). */
3895         if (appData.zippyPlay && !newGame && newMove &&
3896            (!appData.getMoveList || backwardMostMove == 0) && first.initDone) {
3897
3898             if ((gameMode == IcsPlayingWhite && WhiteOnMove(moveNum)) ||
3899                 (gameMode == IcsPlayingBlack && !WhiteOnMove(moveNum))) {
3900                 if (moveList[moveNum - 1][0] == NULLCHAR) {
3901                     sprintf(str, _("Couldn't parse move \"%s\" from ICS"),
3902                             move_str);
3903                     DisplayError(str, 0);
3904                 } else {
3905                     if (first.sendTime) {
3906                         SendTimeRemaining(&first, gameMode == IcsPlayingWhite);
3907                     }
3908                     bookHit = SendMoveToBookUser(moveNum - 1, &first, FALSE); // [HGM] book
3909                     if (firstMove && !bookHit) {
3910                         firstMove = FALSE;
3911                         if (first.useColors) {
3912                           SendToProgram(gameMode == IcsPlayingWhite ?
3913                                         "white\ngo\n" :
3914                                         "black\ngo\n", &first);
3915                         } else {
3916                           SendToProgram("go\n", &first);
3917                         }
3918                         first.maybeThinking = TRUE;
3919                     }
3920                 }
3921             } else if (gameMode == IcsObserving || gameMode == IcsExamining) {
3922               if (moveList[moveNum - 1][0] == NULLCHAR) {
3923                 sprintf(str, _("Couldn't parse move \"%s\" from ICS"), move_str);
3924                 DisplayError(str, 0);
3925               } else {
3926                 if(gameInfo.variant == currentlyInitializedVariant) // [HGM] refrain sending moves engine can't understand!
3927                 SendMoveToProgram(moveNum - 1, &first);
3928               }
3929             }
3930         }
3931 #endif
3932     }
3933
3934     if (moveNum > 0 && !gotPremove && !appData.noGUI) {
3935         /* If move comes from a remote source, animate it.  If it
3936            isn't remote, it will have already been animated. */
3937         if (!pausing && !ics_user_moved && prevMove == moveNum - 1) {
3938             AnimateMove(boards[moveNum - 1], fromX, fromY, toX, toY);
3939         }
3940         if (!pausing && appData.highlightLastMove) {
3941             SetHighlights(fromX, fromY, toX, toY);
3942         }
3943     }
3944
3945     /* Start the clocks */
3946     whiteFlag = blackFlag = FALSE;
3947     appData.clockMode = !(basetime == 0 && increment == 0);
3948     if (ticking == 0) {
3949       ics_clock_paused = TRUE;
3950       StopClocks();
3951     } else if (ticking == 1) {
3952       ics_clock_paused = FALSE;
3953     }
3954     if (gameMode == IcsIdle ||
3955         relation == RELATION_OBSERVING_STATIC ||
3956         relation == RELATION_EXAMINING ||
3957         ics_clock_paused)
3958       DisplayBothClocks();
3959     else
3960       StartClocks();
3961
3962     /* Display opponents and material strengths */
3963     if (gameInfo.variant != VariantBughouse &&
3964         gameInfo.variant != VariantCrazyhouse && !appData.noGUI) {
3965         if (tinyLayout || smallLayout) {
3966             if(gameInfo.variant == VariantNormal)
3967                 sprintf(str, "%s(%d) %s(%d) {%d %d}",
3968                     gameInfo.white, white_stren, gameInfo.black, black_stren,
3969                     basetime, increment);
3970             else
3971                 sprintf(str, "%s(%d) %s(%d) {%d %d w%d}",
3972                     gameInfo.white, white_stren, gameInfo.black, black_stren,
3973                     basetime, increment, (int) gameInfo.variant);
3974         } else {
3975             if(gameInfo.variant == VariantNormal)
3976                 sprintf(str, "%s (%d) vs. %s (%d) {%d %d}",
3977                     gameInfo.white, white_stren, gameInfo.black, black_stren,
3978                     basetime, increment);
3979             else
3980                 sprintf(str, "%s (%d) vs. %s (%d) {%d %d %s}",
3981                     gameInfo.white, white_stren, gameInfo.black, black_stren,
3982                     basetime, increment, VariantName(gameInfo.variant));
3983         }
3984         DisplayTitle(str);
3985   if (appData.debugMode) {
3986     fprintf(debugFP, "Display title '%s, gameInfo.variant = %d'\n", str, gameInfo.variant);
3987   }
3988     }
3989
3990
3991     /* Display the board */
3992     if (!pausing && !appData.noGUI) {
3993
3994       if (appData.premove)
3995           if (!gotPremove ||
3996              ((gameMode == IcsPlayingWhite) && (WhiteOnMove(currentMove))) ||
3997              ((gameMode == IcsPlayingBlack) && (!WhiteOnMove(currentMove))))
3998               ClearPremoveHighlights();
3999
4000       DrawPosition(FALSE, boards[currentMove]);
4001       DisplayMove(moveNum - 1);
4002       if (appData.ringBellAfterMoves && /*!ics_user_moved*/ // [HGM] use absolute method to recognize own move
4003             !((gameMode == IcsPlayingWhite) && (!WhiteOnMove(moveNum)) ||
4004               (gameMode == IcsPlayingBlack) &&  (WhiteOnMove(moveNum))   ) ) {
4005         if(newMove) RingBell(); else PlayIcsUnfinishedSound();
4006       }
4007     }
4008
4009     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
4010 #if ZIPPY
4011     if(bookHit) { // [HGM] book: simulate book reply
4012         static char bookMove[MSG_SIZ]; // a bit generous?
4013
4014         programStats.nodes = programStats.depth = programStats.time =
4015         programStats.score = programStats.got_only_move = 0;
4016         sprintf(programStats.movelist, "%s (xbook)", bookHit);
4017
4018         strcpy(bookMove, "move ");
4019         strcat(bookMove, bookHit);
4020         HandleMachineMove(bookMove, &first);
4021     }
4022 #endif
4023 }
4024
4025 void
4026 GetMoveListEvent()
4027 {
4028     char buf[MSG_SIZ];
4029     if (appData.icsActive && gameMode != IcsIdle && ics_gamenum > 0) {
4030         ics_getting_history = H_REQUESTED;
4031         sprintf(buf, "%smoves %d\n", ics_prefix, ics_gamenum);
4032         SendToICS(buf);
4033     }
4034 }
4035
4036 void
4037 AnalysisPeriodicEvent(force)
4038      int force;
4039 {
4040     if (((programStats.ok_to_send == 0 || programStats.line_is_book)
4041          && !force) || !appData.periodicUpdates)
4042       return;
4043
4044     /* Send . command to Crafty to collect stats */
4045     SendToProgram(".\n", &first);
4046
4047     /* Don't send another until we get a response (this makes
4048        us stop sending to old Crafty's which don't understand
4049        the "." command (sending illegal cmds resets node count & time,
4050        which looks bad)) */
4051     programStats.ok_to_send = 0;
4052 }
4053
4054 void ics_update_width(new_width)
4055         int new_width;
4056 {
4057         ics_printf("set width %d\n", new_width);
4058 }
4059
4060 void
4061 SendMoveToProgram(moveNum, cps)
4062      int moveNum;
4063      ChessProgramState *cps;
4064 {
4065     char buf[MSG_SIZ];
4066
4067     if (cps->useUsermove) {
4068       SendToProgram("usermove ", cps);
4069     }
4070     if (cps->useSAN) {
4071       char *space;
4072       if ((space = strchr(parseList[moveNum], ' ')) != NULL) {
4073         int len = space - parseList[moveNum];
4074         memcpy(buf, parseList[moveNum], len);
4075         buf[len++] = '\n';
4076         buf[len] = NULLCHAR;
4077       } else {
4078         sprintf(buf, "%s\n", parseList[moveNum]);
4079       }
4080       SendToProgram(buf, cps);
4081     } else {
4082       if(cps->alphaRank) { /* [HGM] shogi: temporarily convert to shogi coordinates before sending */
4083         AlphaRank(moveList[moveNum], 4);
4084         SendToProgram(moveList[moveNum], cps);
4085         AlphaRank(moveList[moveNum], 4); // and back
4086       } else
4087       /* Added by Tord: Send castle moves in "O-O" in FRC games if required by
4088        * the engine. It would be nice to have a better way to identify castle
4089        * moves here. */
4090       if((gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom)
4091                                                                          && cps->useOOCastle) {
4092         int fromX = moveList[moveNum][0] - AAA;
4093         int fromY = moveList[moveNum][1] - ONE;
4094         int toX = moveList[moveNum][2] - AAA;
4095         int toY = moveList[moveNum][3] - ONE;
4096         if((boards[moveNum][fromY][fromX] == WhiteKing
4097             && boards[moveNum][toY][toX] == WhiteRook)
4098            || (boards[moveNum][fromY][fromX] == BlackKing
4099                && boards[moveNum][toY][toX] == BlackRook)) {
4100           if(toX > fromX) SendToProgram("O-O\n", cps);
4101           else SendToProgram("O-O-O\n", cps);
4102         }
4103         else SendToProgram(moveList[moveNum], cps);
4104       }
4105       else SendToProgram(moveList[moveNum], cps);
4106       /* End of additions by Tord */
4107     }
4108
4109     /* [HGM] setting up the opening has brought engine in force mode! */
4110     /*       Send 'go' if we are in a mode where machine should play. */
4111     if( (moveNum == 0 && setboardSpoiledMachineBlack && cps == &first) &&
4112         (gameMode == TwoMachinesPlay   ||
4113 #ifdef ZIPPY
4114          gameMode == IcsPlayingBlack     || gameMode == IcsPlayingWhite ||
4115 #endif
4116          gameMode == MachinePlaysBlack || gameMode == MachinePlaysWhite) ) {
4117         SendToProgram("go\n", cps);
4118   if (appData.debugMode) {
4119     fprintf(debugFP, "(extra)\n");
4120   }
4121     }
4122     setboardSpoiledMachineBlack = 0;
4123 }
4124
4125 void
4126 SendMoveToICS(moveType, fromX, fromY, toX, toY)
4127      ChessMove moveType;
4128      int fromX, fromY, toX, toY;
4129 {
4130     char user_move[MSG_SIZ];
4131
4132     switch (moveType) {
4133       default:
4134         sprintf(user_move, _("say Internal error; bad moveType %d (%d,%d-%d,%d)"),
4135                 (int)moveType, fromX, fromY, toX, toY);
4136         DisplayError(user_move + strlen("say "), 0);
4137         break;
4138       case WhiteKingSideCastle:
4139       case BlackKingSideCastle:
4140       case WhiteQueenSideCastleWild:
4141       case BlackQueenSideCastleWild:
4142       /* PUSH Fabien */
4143       case WhiteHSideCastleFR:
4144       case BlackHSideCastleFR:
4145       /* POP Fabien */
4146         sprintf(user_move, "o-o\n");
4147         break;
4148       case WhiteQueenSideCastle:
4149       case BlackQueenSideCastle:
4150       case WhiteKingSideCastleWild:
4151       case BlackKingSideCastleWild:
4152       /* PUSH Fabien */
4153       case WhiteASideCastleFR:
4154       case BlackASideCastleFR:
4155       /* POP Fabien */
4156         sprintf(user_move, "o-o-o\n");
4157         break;
4158       case WhitePromotionQueen:
4159       case BlackPromotionQueen:
4160       case WhitePromotionRook:
4161       case BlackPromotionRook:
4162       case WhitePromotionBishop:
4163       case BlackPromotionBishop:
4164       case WhitePromotionKnight:
4165       case BlackPromotionKnight:
4166       case WhitePromotionKing:
4167       case BlackPromotionKing:
4168       case WhitePromotionChancellor:
4169       case BlackPromotionChancellor:
4170       case WhitePromotionArchbishop:
4171       case BlackPromotionArchbishop:
4172         if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier)
4173             sprintf(user_move, "%c%c%c%c=%c\n",
4174                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4175                 PieceToChar(WhiteFerz));
4176         else if(gameInfo.variant == VariantGreat)
4177             sprintf(user_move, "%c%c%c%c=%c\n",
4178                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4179                 PieceToChar(WhiteMan));
4180         else
4181             sprintf(user_move, "%c%c%c%c=%c\n",
4182                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4183                 PieceToChar(PromoPiece(moveType)));
4184         break;
4185       case WhiteDrop:
4186       case BlackDrop:
4187         sprintf(user_move, "%c@%c%c\n",
4188                 ToUpper(PieceToChar((ChessSquare) fromX)),
4189                 AAA + toX, ONE + toY);
4190         break;
4191       case NormalMove:
4192       case WhiteCapturesEnPassant:
4193       case BlackCapturesEnPassant:
4194       case IllegalMove:  /* could be a variant we don't quite understand */
4195         sprintf(user_move, "%c%c%c%c\n",
4196                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY);
4197         break;
4198     }
4199     SendToICS(user_move);
4200     if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
4201         ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
4202 }
4203
4204 void
4205 CoordsToComputerAlgebraic(rf, ff, rt, ft, promoChar, move)
4206      int rf, ff, rt, ft;
4207      char promoChar;
4208      char move[7];
4209 {
4210     if (rf == DROP_RANK) {
4211         sprintf(move, "%c@%c%c\n",
4212                 ToUpper(PieceToChar((ChessSquare) ff)), AAA + ft, ONE + rt);
4213     } else {
4214         if (promoChar == 'x' || promoChar == NULLCHAR) {
4215             sprintf(move, "%c%c%c%c\n",
4216                     AAA + ff, ONE + rf, AAA + ft, ONE + rt);
4217         } else {
4218             sprintf(move, "%c%c%c%c%c\n",
4219                     AAA + ff, ONE + rf, AAA + ft, ONE + rt, promoChar);
4220         }
4221     }
4222 }
4223
4224 void
4225 ProcessICSInitScript(f)
4226      FILE *f;
4227 {
4228     char buf[MSG_SIZ];
4229
4230     while (fgets(buf, MSG_SIZ, f)) {
4231         SendToICSDelayed(buf,(long)appData.msLoginDelay);
4232     }
4233
4234     fclose(f);
4235 }
4236
4237
4238 /* [HGM] Shogi move preprocessor: swap digits for letters, vice versa */
4239 void
4240 AlphaRank(char *move, int n)
4241 {
4242 //    char *p = move, c; int x, y;
4243
4244     if (appData.debugMode) {
4245         fprintf(debugFP, "alphaRank(%s,%d)\n", move, n);
4246     }
4247
4248     if(move[1]=='*' &&
4249        move[2]>='0' && move[2]<='9' &&
4250        move[3]>='a' && move[3]<='x'    ) {
4251         move[1] = '@';
4252         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
4253         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
4254     } else
4255     if(move[0]>='0' && move[0]<='9' &&
4256        move[1]>='a' && move[1]<='x' &&
4257        move[2]>='0' && move[2]<='9' &&
4258        move[3]>='a' && move[3]<='x'    ) {
4259         /* input move, Shogi -> normal */
4260         move[0] = BOARD_RGHT  -1 - (move[0]-'1') + AAA;
4261         move[1] = BOARD_HEIGHT-1 - (move[1]-'a') + ONE;
4262         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
4263         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
4264     } else
4265     if(move[1]=='@' &&
4266        move[3]>='0' && move[3]<='9' &&
4267        move[2]>='a' && move[2]<='x'    ) {
4268         move[1] = '*';
4269         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
4270         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
4271     } else
4272     if(
4273        move[0]>='a' && move[0]<='x' &&
4274        move[3]>='0' && move[3]<='9' &&
4275        move[2]>='a' && move[2]<='x'    ) {
4276          /* output move, normal -> Shogi */
4277         move[0] = BOARD_RGHT - 1 - (move[0]-AAA) + '1';
4278         move[1] = BOARD_HEIGHT-1 - (move[1]-ONE) + 'a';
4279         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
4280         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
4281         if(move[4] == PieceToChar(BlackQueen)) move[4] = '+';
4282     }
4283     if (appData.debugMode) {
4284         fprintf(debugFP, "   out = '%s'\n", move);
4285     }
4286 }
4287
4288 /* Parser for moves from gnuchess, ICS, or user typein box */
4289 Boolean
4290 ParseOneMove(move, moveNum, moveType, fromX, fromY, toX, toY, promoChar)
4291      char *move;
4292      int moveNum;
4293      ChessMove *moveType;
4294      int *fromX, *fromY, *toX, *toY;
4295      char *promoChar;
4296 {
4297     if (appData.debugMode) {
4298         fprintf(debugFP, "move to parse: %s\n", move);
4299     }
4300     *moveType = yylexstr(moveNum, move);
4301
4302     switch (*moveType) {
4303       case WhitePromotionChancellor:
4304       case BlackPromotionChancellor:
4305       case WhitePromotionArchbishop:
4306       case BlackPromotionArchbishop:
4307       case WhitePromotionQueen:
4308       case BlackPromotionQueen:
4309       case WhitePromotionRook:
4310       case BlackPromotionRook:
4311       case WhitePromotionBishop:
4312       case BlackPromotionBishop:
4313       case WhitePromotionKnight:
4314       case BlackPromotionKnight:
4315       case WhitePromotionKing:
4316       case BlackPromotionKing:
4317       case NormalMove:
4318       case WhiteCapturesEnPassant:
4319       case BlackCapturesEnPassant:
4320       case WhiteKingSideCastle:
4321       case WhiteQueenSideCastle:
4322       case BlackKingSideCastle:
4323       case BlackQueenSideCastle:
4324       case WhiteKingSideCastleWild:
4325       case WhiteQueenSideCastleWild:
4326       case BlackKingSideCastleWild:
4327       case BlackQueenSideCastleWild:
4328       /* Code added by Tord: */
4329       case WhiteHSideCastleFR:
4330       case WhiteASideCastleFR:
4331       case BlackHSideCastleFR:
4332       case BlackASideCastleFR:
4333       /* End of code added by Tord */
4334       case IllegalMove:         /* bug or odd chess variant */
4335         *fromX = currentMoveString[0] - AAA;
4336         *fromY = currentMoveString[1] - ONE;
4337         *toX = currentMoveString[2] - AAA;
4338         *toY = currentMoveString[3] - ONE;
4339         *promoChar = currentMoveString[4];
4340         if (*fromX < BOARD_LEFT || *fromX >= BOARD_RGHT || *fromY < 0 || *fromY >= BOARD_HEIGHT ||
4341             *toX < BOARD_LEFT || *toX >= BOARD_RGHT || *toY < 0 || *toY >= BOARD_HEIGHT) {
4342     if (appData.debugMode) {
4343         fprintf(debugFP, "Off-board move (%d,%d)-(%d,%d)%c, type = %d\n", *fromX, *fromY, *toX, *toY, *promoChar, *moveType);
4344     }
4345             *fromX = *fromY = *toX = *toY = 0;
4346             return FALSE;
4347         }
4348         if (appData.testLegality) {
4349           return (*moveType != IllegalMove);
4350         } else {
4351           return !(fromX == fromY && toX == toY);
4352         }
4353
4354       case WhiteDrop:
4355       case BlackDrop:
4356         *fromX = *moveType == WhiteDrop ?
4357           (int) CharToPiece(ToUpper(currentMoveString[0])) :
4358           (int) CharToPiece(ToLower(currentMoveString[0]));
4359         *fromY = DROP_RANK;
4360         *toX = currentMoveString[2] - AAA;
4361         *toY = currentMoveString[3] - ONE;
4362         *promoChar = NULLCHAR;
4363         return TRUE;
4364
4365       case AmbiguousMove:
4366       case ImpossibleMove:
4367       case (ChessMove) 0:       /* end of file */
4368       case ElapsedTime:
4369       case Comment:
4370       case PGNTag:
4371       case NAG:
4372       case WhiteWins:
4373       case BlackWins:
4374       case GameIsDrawn:
4375       default:
4376     if (appData.debugMode) {
4377         fprintf(debugFP, "Impossible move %s, type = %d\n", currentMoveString, *moveType);
4378     }
4379         /* bug? */
4380         *fromX = *fromY = *toX = *toY = 0;
4381         *promoChar = NULLCHAR;
4382         return FALSE;
4383     }
4384 }
4385
4386 // [HGM] shuffle: a general way to suffle opening setups, applicable to arbitrary variants.
4387 // All positions will have equal probability, but the current method will not provide a unique
4388 // numbering scheme for arrays that contain 3 or more pieces of the same kind.
4389 #define DARK 1
4390 #define LITE 2
4391 #define ANY 3
4392
4393 int squaresLeft[4];
4394 int piecesLeft[(int)BlackPawn];
4395 int seed, nrOfShuffles;
4396
4397 void GetPositionNumber()
4398 {       // sets global variable seed
4399         int i;
4400
4401         seed = appData.defaultFrcPosition;
4402         if(seed < 0) { // randomize based on time for negative FRC position numbers
4403                 for(i=0; i<50; i++) seed += random();
4404                 seed = random() ^ random() >> 8 ^ random() << 8;
4405                 if(seed<0) seed = -seed;
4406         }
4407 }
4408
4409 int put(Board board, int pieceType, int rank, int n, int shade)
4410 // put the piece on the (n-1)-th empty squares of the given shade
4411 {
4412         int i;
4413
4414         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
4415                 if( (((i-BOARD_LEFT)&1)+1) & shade && board[rank][i] == EmptySquare && n-- == 0) {
4416                         board[rank][i] = (ChessSquare) pieceType;
4417                         squaresLeft[((i-BOARD_LEFT)&1) + 1]--;
4418                         squaresLeft[ANY]--;
4419                         piecesLeft[pieceType]--;
4420                         return i;
4421                 }
4422         }
4423         return -1;
4424 }
4425
4426
4427 void AddOnePiece(Board board, int pieceType, int rank, int shade)
4428 // calculate where the next piece goes, (any empty square), and put it there
4429 {
4430         int i;
4431
4432         i = seed % squaresLeft[shade];
4433         nrOfShuffles *= squaresLeft[shade];
4434         seed /= squaresLeft[shade];
4435         put(board, pieceType, rank, i, shade);
4436 }
4437
4438 void AddTwoPieces(Board board, int pieceType, int rank)
4439 // calculate where the next 2 identical pieces go, (any empty square), and put it there
4440 {
4441         int i, n=squaresLeft[ANY], j=n-1, k;
4442
4443         k = n*(n-1)/2; // nr of possibilities, not counting permutations
4444         i = seed % k;  // pick one
4445         nrOfShuffles *= k;
4446         seed /= k;
4447         while(i >= j) i -= j--;
4448         j = n - 1 - j; i += j;
4449         put(board, pieceType, rank, j, ANY);
4450         put(board, pieceType, rank, i, ANY);
4451 }
4452
4453 void SetUpShuffle(Board board, int number)
4454 {
4455         int i, p, first=1;
4456
4457         GetPositionNumber(); nrOfShuffles = 1;
4458
4459         squaresLeft[DARK] = (BOARD_RGHT - BOARD_LEFT + 1)/2;
4460         squaresLeft[ANY]  = BOARD_RGHT - BOARD_LEFT;
4461         squaresLeft[LITE] = squaresLeft[ANY] - squaresLeft[DARK];
4462
4463         for(p = 0; p<=(int)WhiteKing; p++) piecesLeft[p] = 0;
4464
4465         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // count pieces and clear board
4466             p = (int) board[0][i];
4467             if(p < (int) BlackPawn) piecesLeft[p] ++;
4468             board[0][i] = EmptySquare;
4469         }
4470
4471         if(PosFlags(0) & F_ALL_CASTLE_OK) {
4472             // shuffles restricted to allow normal castling put KRR first
4473             if(piecesLeft[(int)WhiteKing]) // King goes rightish of middle
4474                 put(board, WhiteKing, 0, (gameInfo.boardWidth+1)/2, ANY);
4475             else if(piecesLeft[(int)WhiteUnicorn]) // in Knightmate Unicorn castles
4476                 put(board, WhiteUnicorn, 0, (gameInfo.boardWidth+1)/2, ANY);
4477             if(piecesLeft[(int)WhiteRook]) // First supply a Rook for K-side castling
4478                 put(board, WhiteRook, 0, gameInfo.boardWidth-2, ANY);
4479             if(piecesLeft[(int)WhiteRook]) // Then supply a Rook for Q-side castling
4480                 put(board, WhiteRook, 0, 0, ANY);
4481             // in variants with super-numerary Kings and Rooks, we leave these for the shuffle
4482         }
4483
4484         if(((BOARD_RGHT-BOARD_LEFT) & 1) == 0)
4485             // only for even boards make effort to put pairs of colorbound pieces on opposite colors
4486             for(p = (int) WhiteKing; p > (int) WhitePawn; p--) {
4487                 if(p != (int) WhiteBishop && p != (int) WhiteFerz && p != (int) WhiteAlfil) continue;
4488                 while(piecesLeft[p] >= 2) {
4489                     AddOnePiece(board, p, 0, LITE);
4490                     AddOnePiece(board, p, 0, DARK);
4491                 }
4492                 // Odd color-bound pieces are shuffled with the rest (to not run out of paired squares)
4493             }
4494
4495         for(p = (int) WhiteKing - 2; p > (int) WhitePawn; p--) {
4496             // Remaining pieces (non-colorbound, or odd color bound) can be put anywhere
4497             // but we leave King and Rooks for last, to possibly obey FRC restriction
4498             if(p == (int)WhiteRook) continue;
4499             while(piecesLeft[p] >= 2) AddTwoPieces(board, p, 0); // add in pairs, for not counting permutations
4500             if(piecesLeft[p]) AddOnePiece(board, p, 0, ANY);     // add the odd piece
4501         }
4502
4503         // now everything is placed, except perhaps King (Unicorn) and Rooks
4504
4505         if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
4506             // Last King gets castling rights
4507             while(piecesLeft[(int)WhiteUnicorn]) {
4508                 i = put(board, WhiteUnicorn, 0, piecesLeft[(int)WhiteRook]/2, ANY);
4509                 initialRights[2]  = initialRights[5]  = castlingRights[0][2] = castlingRights[0][5] = i;
4510             }
4511
4512             while(piecesLeft[(int)WhiteKing]) {
4513                 i = put(board, WhiteKing, 0, piecesLeft[(int)WhiteRook]/2, ANY);
4514                 initialRights[2]  = initialRights[5]  = castlingRights[0][2] = castlingRights[0][5] = i;
4515             }
4516
4517
4518         } else {
4519             while(piecesLeft[(int)WhiteKing])    AddOnePiece(board, WhiteKing, 0, ANY);
4520             while(piecesLeft[(int)WhiteUnicorn]) AddOnePiece(board, WhiteUnicorn, 0, ANY);
4521         }
4522
4523         // Only Rooks can be left; simply place them all
4524         while(piecesLeft[(int)WhiteRook]) {
4525                 i = put(board, WhiteRook, 0, 0, ANY);
4526                 if(PosFlags(0) & F_FRC_TYPE_CASTLING) { // first and last Rook get FRC castling rights
4527                         if(first) {
4528                                 first=0;
4529                                 initialRights[1]  = initialRights[4]  = castlingRights[0][1] = castlingRights[0][4] = i;
4530                         }
4531                         initialRights[0]  = initialRights[3]  = castlingRights[0][0] = castlingRights[0][3] = i;
4532                 }
4533         }
4534         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // copy black from white
4535             board[BOARD_HEIGHT-1][i] =  (int) board[0][i] < BlackPawn ? WHITE_TO_BLACK board[0][i] : EmptySquare;
4536         }
4537
4538         if(number >= 0) appData.defaultFrcPosition %= nrOfShuffles; // normalize
4539 }
4540
4541 int SetCharTable( char *table, const char * map )
4542 /* [HGM] moved here from winboard.c because of its general usefulness */
4543 /*       Basically a safe strcpy that uses the last character as King */
4544 {
4545     int result = FALSE; int NrPieces;
4546
4547     if( map != NULL && (NrPieces=strlen(map)) <= (int) EmptySquare
4548                     && NrPieces >= 12 && !(NrPieces&1)) {
4549         int i; /* [HGM] Accept even length from 12 to 34 */
4550
4551         for( i=0; i<(int) EmptySquare; i++ ) table[i] = '.';
4552         for( i=0; i<NrPieces/2-1; i++ ) {
4553             table[i] = map[i];
4554             table[i + (int)BlackPawn - (int) WhitePawn] = map[i+NrPieces/2];
4555         }
4556         table[(int) WhiteKing]  = map[NrPieces/2-1];
4557         table[(int) BlackKing]  = map[NrPieces-1];
4558
4559         result = TRUE;
4560     }
4561
4562     return result;
4563 }
4564
4565 void Prelude(Board board)
4566 {       // [HGM] superchess: random selection of exo-pieces
4567         int i, j, k; ChessSquare p;
4568         static ChessSquare exoPieces[4] = { WhiteAngel, WhiteMarshall, WhiteSilver, WhiteLance };
4569
4570         GetPositionNumber(); // use FRC position number
4571
4572         if(appData.pieceToCharTable != NULL) { // select pieces to participate from given char table
4573             SetCharTable(pieceToChar, appData.pieceToCharTable);
4574             for(i=(int)WhiteQueen+1, j=0; i<(int)WhiteKing && j<4; i++)
4575                 if(PieceToChar((ChessSquare)i) != '.') exoPieces[j++] = (ChessSquare) i;
4576         }
4577
4578         j = seed%4;                 seed /= 4;
4579         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
4580         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
4581         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
4582         j = seed%3 + (seed%3 >= j); seed /= 3;
4583         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
4584         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
4585         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
4586         j = seed%3;                 seed /= 3;
4587         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
4588         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
4589         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
4590         j = seed%2 + (seed%2 >= j); seed /= 2;
4591         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
4592         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
4593         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
4594         j = seed%4; seed /= 4; put(board, exoPieces[3],    0, j, ANY);
4595         j = seed%3; seed /= 3; put(board, exoPieces[2],   0, j, ANY);
4596         j = seed%2; seed /= 2; put(board, exoPieces[1], 0, j, ANY);
4597         put(board, exoPieces[0],    0, 0, ANY);
4598         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) board[BOARD_HEIGHT-1][i] = WHITE_TO_BLACK board[0][i];
4599 }
4600
4601 void
4602 InitPosition(redraw)
4603      int redraw;
4604 {
4605     ChessSquare (* pieces)[BOARD_SIZE];
4606     int i, j, pawnRow, overrule,
4607     oldx = gameInfo.boardWidth,
4608     oldy = gameInfo.boardHeight,
4609     oldh = gameInfo.holdingsWidth,
4610     oldv = gameInfo.variant;
4611
4612     if(appData.icsActive) shuffleOpenings = FALSE; // [HGM] shuffle: in ICS mode, only shuffle on ICS request
4613
4614     /* [AS] Initialize pv info list [HGM] and game status */
4615     {
4616         for( i=0; i<MAX_MOVES; i++ ) {
4617             pvInfoList[i].depth = 0;
4618             epStatus[i]=EP_NONE;
4619             for( j=0; j<BOARD_SIZE; j++ ) castlingRights[i][j] = -1;
4620         }
4621
4622         initialRulePlies = 0; /* 50-move counter start */
4623
4624         castlingRank[0] = castlingRank[1] = castlingRank[2] = 0;
4625         castlingRank[3] = castlingRank[4] = castlingRank[5] = BOARD_HEIGHT-1;
4626     }
4627
4628
4629     /* [HGM] logic here is completely changed. In stead of full positions */
4630     /* the initialized data only consist of the two backranks. The switch */
4631     /* selects which one we will use, which is than copied to the Board   */
4632     /* initialPosition, which for the rest is initialized by Pawns and    */
4633     /* empty squares. This initial position is then copied to boards[0],  */
4634     /* possibly after shuffling, so that it remains available.            */
4635
4636     gameInfo.holdingsWidth = 0; /* default board sizes */
4637     gameInfo.boardWidth    = 8;
4638     gameInfo.boardHeight   = 8;
4639     gameInfo.holdingsSize  = 0;
4640     nrCastlingRights = -1; /* [HGM] Kludge to indicate default should be used */
4641     for(i=0; i<BOARD_SIZE; i++) initialRights[i] = -1; /* but no rights yet */
4642     SetCharTable(pieceToChar, "PNBRQ...........Kpnbrq...........k");
4643
4644     switch (gameInfo.variant) {
4645     case VariantFischeRandom:
4646       shuffleOpenings = TRUE;
4647     default:
4648       pieces = FIDEArray;
4649       break;
4650     case VariantShatranj:
4651       pieces = ShatranjArray;
4652       nrCastlingRights = 0;
4653       SetCharTable(pieceToChar, "PN.R.QB...Kpn.r.qb...k");
4654       break;
4655     case VariantTwoKings:
4656       pieces = twoKingsArray;
4657       break;
4658     case VariantCapaRandom:
4659       shuffleOpenings = TRUE;
4660     case VariantCapablanca:
4661       pieces = CapablancaArray;
4662       gameInfo.boardWidth = 10;
4663       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
4664       break;
4665     case VariantGothic:
4666       pieces = GothicArray;
4667       gameInfo.boardWidth = 10;
4668       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
4669       break;
4670     case VariantJanus:
4671       pieces = JanusArray;
4672       gameInfo.boardWidth = 10;
4673       SetCharTable(pieceToChar, "PNBRQ..JKpnbrq..jk");
4674       nrCastlingRights = 6;
4675         castlingRights[0][0] = initialRights[0] = BOARD_RGHT-1;
4676         castlingRights[0][1] = initialRights[1] = BOARD_LEFT;
4677         castlingRights[0][2] = initialRights[2] =(BOARD_WIDTH-1)>>1;
4678         castlingRights[0][3] = initialRights[3] = BOARD_RGHT-1;
4679         castlingRights[0][4] = initialRights[4] = BOARD_LEFT;
4680         castlingRights[0][5] = initialRights[5] =(BOARD_WIDTH-1)>>1;
4681       break;
4682     case VariantFalcon:
4683       pieces = FalconArray;
4684       gameInfo.boardWidth = 10;
4685       SetCharTable(pieceToChar, "PNBRQ.............FKpnbrq.............fk");
4686       break;
4687     case VariantXiangqi:
4688       pieces = XiangqiArray;
4689       gameInfo.boardWidth  = 9;
4690       gameInfo.boardHeight = 10;
4691       nrCastlingRights = 0;
4692       SetCharTable(pieceToChar, "PH.R.AE..K.C.ph.r.ae..k.c.");
4693       break;
4694     case VariantShogi:
4695       pieces = ShogiArray;
4696       gameInfo.boardWidth  = 9;
4697       gameInfo.boardHeight = 9;
4698       gameInfo.holdingsSize = 7;
4699       nrCastlingRights = 0;
4700       SetCharTable(pieceToChar, "PNBRLS...G.++++++Kpnbrls...g.++++++k");
4701       break;
4702     case VariantCourier:
4703       pieces = CourierArray;
4704       gameInfo.boardWidth  = 12;
4705       nrCastlingRights = 0;
4706       SetCharTable(pieceToChar, "PNBR.FE..WMKpnbr.fe..wmk");
4707       for(i=0; i<BOARD_SIZE; i++) initialRights[i] = -1;
4708       break;
4709     case VariantKnightmate:
4710       pieces = KnightmateArray;
4711       SetCharTable(pieceToChar, "P.BRQ.....M.........K.p.brq.....m.........k.");
4712       break;
4713     case VariantFairy:
4714       pieces = fairyArray;
4715       SetCharTable(pieceToChar, "PNBRQFEACWMOHIJGDVSLUKpnbrqfeacwmohijgdvsluk");
4716       break;
4717     case VariantGreat:
4718       pieces = GreatArray;
4719       gameInfo.boardWidth = 10;
4720       SetCharTable(pieceToChar, "PN....E...S..HWGMKpn....e...s..hwgmk");
4721       gameInfo.holdingsSize = 8;
4722       break;
4723     case VariantSuper:
4724       pieces = FIDEArray;
4725       SetCharTable(pieceToChar, "PNBRQ..SE.......V.AKpnbrq..se.......v.ak");
4726       gameInfo.holdingsSize = 8;
4727       startedFromSetupPosition = TRUE;
4728       break;
4729     case VariantCrazyhouse:
4730     case VariantBughouse:
4731       pieces = FIDEArray;
4732       SetCharTable(pieceToChar, "PNBRQ.......~~~~Kpnbrq.......~~~~k");
4733       gameInfo.holdingsSize = 5;
4734       break;
4735     case VariantWildCastle:
4736       pieces = FIDEArray;
4737       /* !!?shuffle with kings guaranteed to be on d or e file */
4738       shuffleOpenings = 1;
4739       break;
4740     case VariantNoCastle:
4741       pieces = FIDEArray;
4742       nrCastlingRights = 0;
4743       for(i=0; i<BOARD_SIZE; i++) initialRights[i] = -1;
4744       /* !!?unconstrained back-rank shuffle */
4745       shuffleOpenings = 1;
4746       break;
4747     }
4748
4749     overrule = 0;
4750     if(appData.NrFiles >= 0) {
4751         if(gameInfo.boardWidth != appData.NrFiles) overrule++;
4752         gameInfo.boardWidth = appData.NrFiles;
4753     }
4754     if(appData.NrRanks >= 0) {
4755         gameInfo.boardHeight = appData.NrRanks;
4756     }
4757     if(appData.holdingsSize >= 0) {
4758         i = appData.holdingsSize;
4759         if(i > gameInfo.boardHeight) i = gameInfo.boardHeight;
4760         gameInfo.holdingsSize = i;
4761     }
4762     if(gameInfo.holdingsSize) gameInfo.holdingsWidth = 2;
4763     if(BOARD_HEIGHT > BOARD_SIZE || BOARD_WIDTH > BOARD_SIZE)
4764         DisplayFatalError(_("Recompile to support this BOARD_SIZE!"), 0, 2);
4765
4766     pawnRow = gameInfo.boardHeight - 7; /* seems to work in all common variants */
4767     if(pawnRow < 1) pawnRow = 1;
4768
4769     /* User pieceToChar list overrules defaults */
4770     if(appData.pieceToCharTable != NULL)
4771         SetCharTable(pieceToChar, appData.pieceToCharTable);
4772
4773     for( j=0; j<BOARD_WIDTH; j++ ) { ChessSquare s = EmptySquare;
4774
4775         if(j==BOARD_LEFT-1 || j==BOARD_RGHT)
4776             s = (ChessSquare) 0; /* account holding counts in guard band */
4777         for( i=0; i<BOARD_HEIGHT; i++ )
4778             initialPosition[i][j] = s;
4779
4780         if(j < BOARD_LEFT || j >= BOARD_RGHT || overrule) continue;
4781         initialPosition[0][j] = pieces[0][j-gameInfo.holdingsWidth];
4782         initialPosition[pawnRow][j] = WhitePawn;
4783         initialPosition[BOARD_HEIGHT-pawnRow-1][j] = BlackPawn;
4784         if(gameInfo.variant == VariantXiangqi) {
4785             if(j&1) {
4786                 initialPosition[pawnRow][j] =
4787                 initialPosition[BOARD_HEIGHT-pawnRow-1][j] = EmptySquare;
4788                 if(j==BOARD_LEFT+1 || j>=BOARD_RGHT-2) {
4789                    initialPosition[2][j] = WhiteCannon;
4790                    initialPosition[BOARD_HEIGHT-3][j] = BlackCannon;
4791                 }
4792             }
4793         }
4794         initialPosition[BOARD_HEIGHT-1][j] =  pieces[1][j-gameInfo.holdingsWidth];
4795     }
4796     if( (gameInfo.variant == VariantShogi) && !overrule ) {
4797
4798             j=BOARD_LEFT+1;
4799             initialPosition[1][j] = WhiteBishop;
4800             initialPosition[BOARD_HEIGHT-2][j] = BlackRook;
4801             j=BOARD_RGHT-2;
4802             initialPosition[1][j] = WhiteRook;
4803             initialPosition[BOARD_HEIGHT-2][j] = BlackBishop;
4804     }
4805
4806     if( nrCastlingRights == -1) {
4807         /* [HGM] Build normal castling rights (must be done after board sizing!) */
4808         /*       This sets default castling rights from none to normal corners   */
4809         /* Variants with other castling rights must set them themselves above    */
4810         nrCastlingRights = 6;
4811
4812         castlingRights[0][0] = initialRights[0] = BOARD_RGHT-1;
4813         castlingRights[0][1] = initialRights[1] = BOARD_LEFT;
4814         castlingRights[0][2] = initialRights[2] = BOARD_WIDTH>>1;
4815         castlingRights[0][3] = initialRights[3] = BOARD_RGHT-1;
4816         castlingRights[0][4] = initialRights[4] = BOARD_LEFT;
4817         castlingRights[0][5] = initialRights[5] = BOARD_WIDTH>>1;
4818      }
4819
4820      if(gameInfo.variant == VariantSuper) Prelude(initialPosition);
4821      if(gameInfo.variant == VariantGreat) { // promotion commoners
4822         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-1] = WhiteMan;
4823         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-2] = 9;
4824         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][0] = BlackMan;
4825         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][1] = 9;
4826      }
4827   if (appData.debugMode) {
4828     fprintf(debugFP, "shuffleOpenings = %d\n", shuffleOpenings);
4829   }
4830     if(shuffleOpenings) {
4831         SetUpShuffle(initialPosition, appData.defaultFrcPosition);
4832         startedFromSetupPosition = TRUE;
4833     }
4834     if(startedFromPositionFile) {
4835       /* [HGM] loadPos: use PositionFile for every new game */
4836       CopyBoard(initialPosition, filePosition);
4837       for(i=0; i<nrCastlingRights; i++)
4838           castlingRights[0][i] = initialRights[i] = fileRights[i];
4839       startedFromSetupPosition = TRUE;
4840     }
4841
4842     CopyBoard(boards[0], initialPosition);
4843
4844     if(oldx != gameInfo.boardWidth ||
4845        oldy != gameInfo.boardHeight ||
4846        oldh != gameInfo.holdingsWidth
4847 #ifdef GOTHIC
4848        || oldv == VariantGothic ||        // For licensing popups
4849        gameInfo.variant == VariantGothic
4850 #endif
4851 #ifdef FALCON
4852        || oldv == VariantFalcon ||
4853        gameInfo.variant == VariantFalcon
4854 #endif
4855                                          )
4856             InitDrawingSizes(-2 ,0);
4857
4858     if (redraw)
4859       DrawPosition(TRUE, boards[currentMove]);
4860 }
4861
4862 void
4863 SendBoard(cps, moveNum)
4864      ChessProgramState *cps;
4865      int moveNum;
4866 {
4867     char message[MSG_SIZ];
4868
4869     if (cps->useSetboard) {
4870       char* fen = PositionToFEN(moveNum, cps->fenOverride);
4871       sprintf(message, "setboard %s\n", fen);
4872       SendToProgram(message, cps);
4873       free(fen);
4874
4875     } else {
4876       ChessSquare *bp;
4877       int i, j;
4878       /* Kludge to set black to move, avoiding the troublesome and now
4879        * deprecated "black" command.
4880        */
4881       if (!WhiteOnMove(moveNum)) SendToProgram("a2a3\n", cps);
4882
4883       SendToProgram("edit\n", cps);
4884       SendToProgram("#\n", cps);
4885       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
4886         bp = &boards[moveNum][i][BOARD_LEFT];
4887         for (j = BOARD_LEFT; j < BOARD_RGHT; j++, bp++) {
4888           if ((int) *bp < (int) BlackPawn) {
4889             sprintf(message, "%c%c%c\n", PieceToChar(*bp),
4890                     AAA + j, ONE + i);
4891             if(message[0] == '+' || message[0] == '~') {
4892                 sprintf(message, "%c%c%c+\n",
4893                         PieceToChar((ChessSquare)(DEMOTED *bp)),
4894                         AAA + j, ONE + i);
4895             }
4896             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
4897                 message[1] = BOARD_RGHT   - 1 - j + '1';
4898                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
4899             }
4900             SendToProgram(message, cps);
4901           }
4902         }
4903       }
4904
4905       SendToProgram("c\n", cps);
4906       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
4907         bp = &boards[moveNum][i][BOARD_LEFT];
4908         for (j = BOARD_LEFT; j < BOARD_RGHT; j++, bp++) {
4909           if (((int) *bp != (int) EmptySquare)
4910               && ((int) *bp >= (int) BlackPawn)) {
4911             sprintf(message, "%c%c%c\n", ToUpper(PieceToChar(*bp)),
4912                     AAA + j, ONE + i);
4913             if(message[0] == '+' || message[0] == '~') {
4914                 sprintf(message, "%c%c%c+\n",
4915                         PieceToChar((ChessSquare)(DEMOTED *bp)),
4916                         AAA + j, ONE + i);
4917             }
4918             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
4919                 message[1] = BOARD_RGHT   - 1 - j + '1';
4920                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
4921             }
4922             SendToProgram(message, cps);
4923           }
4924         }
4925       }
4926
4927       SendToProgram(".\n", cps);
4928     }
4929     setboardSpoiledMachineBlack = 0; /* [HGM] assume WB 4.2.7 already solves this after sending setboard */
4930 }
4931
4932 int
4933 HasPromotionChoice(int fromX, int fromY, int toX, int toY, char *promoChoice)
4934 {
4935     /* [HGM] rewritten IsPromotion to only flag promotions that offer a choice */
4936     /* [HGM] add Shogi promotions */
4937     int promotionZoneSize=1, highestPromotingPiece = (int)WhitePawn;
4938     ChessSquare piece;
4939     ChessMove moveType;
4940     Boolean premove;
4941
4942     if(fromX < BOARD_LEFT || fromX >= BOARD_RGHT) return FALSE; // drop
4943     if(toX   < BOARD_LEFT || toX   >= BOARD_RGHT) return FALSE; // move into holdings
4944
4945     if(gameMode == EditPosition || gameInfo.variant == VariantXiangqi || // no promotions
4946       !(fromX >=0 && fromY >= 0 && toX >= 0 && toY >= 0) ) // invalid move
4947         return FALSE;
4948
4949     piece = boards[currentMove][fromY][fromX];
4950     if(gameInfo.variant == VariantShogi) {
4951         promotionZoneSize = 3;
4952         highestPromotingPiece = (int)WhiteFerz;
4953     }
4954
4955     // next weed out all moves that do not touch the promotion zone at all
4956     if((int)piece >= BlackPawn) {
4957         if(toY >= promotionZoneSize && fromY >= promotionZoneSize)
4958              return FALSE;
4959         highestPromotingPiece = WHITE_TO_BLACK highestPromotingPiece;
4960     } else {
4961         if(  toY < BOARD_HEIGHT - promotionZoneSize &&
4962            fromY < BOARD_HEIGHT - promotionZoneSize) return FALSE;
4963     }
4964
4965     if( (int)piece > highestPromotingPiece ) return FALSE; // non-promoting piece
4966
4967     // weed out mandatory Shogi promotions
4968     if(gameInfo.variant == VariantShogi) {
4969         if(piece >= BlackPawn) {
4970             if(toY == 0 && piece == BlackPawn ||
4971                toY == 0 && piece == BlackQueen ||
4972                toY <= 1 && piece == BlackKnight) {
4973                 *promoChoice = '+';
4974                 return FALSE;
4975             }
4976         } else {
4977             if(toY == BOARD_HEIGHT-1 && piece == WhitePawn ||
4978                toY == BOARD_HEIGHT-1 && piece == WhiteQueen ||
4979                toY >= BOARD_HEIGHT-2 && piece == WhiteKnight) {
4980                 *promoChoice = '+';
4981                 return FALSE;
4982             }
4983         }
4984     }
4985
4986     // weed out obviously illegal Pawn moves
4987     if(appData.testLegality  && (piece == WhitePawn || piece == BlackPawn) ) {
4988         if(toX > fromX+1 || toX < fromX-1) return FALSE; // wide
4989         if(piece == WhitePawn && toY != fromY+1) return FALSE; // deep
4990         if(piece == BlackPawn && toY != fromY-1) return FALSE; // deep
4991         if(fromX != toX && gameInfo.variant == VariantShogi) return FALSE;
4992         // note we are not allowed to test for valid (non-)capture, due to premove
4993     }
4994
4995     // we either have a choice what to promote to, or (in Shogi) whether to promote
4996     if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier) {
4997         *promoChoice = PieceToChar(BlackFerz);  // no choice
4998         return FALSE;
4999     }
5000     if(appData.alwaysPromoteToQueen) { // predetermined
5001         if(gameInfo.variant == VariantSuicide || gameInfo.variant == VariantLosers)
5002              *promoChoice = PieceToChar(BlackKing); // in Suicide Q is the last thing we want
5003         else *promoChoice = PieceToChar(BlackQueen);
5004         return FALSE;
5005     }
5006
5007     // suppress promotion popup on illegal moves that are not premoves
5008     premove = gameMode == IcsPlayingWhite && !WhiteOnMove(currentMove) ||
5009               gameMode == IcsPlayingBlack &&  WhiteOnMove(currentMove);
5010     if(appData.testLegality && !premove) {
5011         moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
5012                         epStatus[currentMove], castlingRights[currentMove],
5013                         fromY, fromX, toY, toX, NULLCHAR);
5014         if(moveType != WhitePromotionQueen && moveType  != BlackPromotionQueen &&
5015            moveType != WhitePromotionKnight && moveType != BlackPromotionKnight)
5016             return FALSE;
5017     }
5018
5019     return TRUE;
5020 }
5021
5022 int
5023 InPalace(row, column)
5024      int row, column;
5025 {   /* [HGM] for Xiangqi */
5026     if( (row < 3 || row > BOARD_HEIGHT-4) &&
5027          column < (BOARD_WIDTH + 4)/2 &&
5028          column > (BOARD_WIDTH - 5)/2 ) return TRUE;
5029     return FALSE;
5030 }
5031
5032 int
5033 PieceForSquare (x, y)
5034      int x;
5035      int y;
5036 {
5037   if (x < 0 || x >= BOARD_WIDTH || y < 0 || y >= BOARD_HEIGHT)
5038      return -1;
5039   else
5040      return boards[currentMove][y][x];
5041 }
5042
5043 int
5044 OKToStartUserMove(x, y)
5045      int x, y;
5046 {
5047     ChessSquare from_piece;
5048     int white_piece;
5049
5050     if (matchMode) return FALSE;
5051     if (gameMode == EditPosition) return TRUE;
5052
5053     if (x >= 0 && y >= 0)
5054       from_piece = boards[currentMove][y][x];
5055     else
5056       from_piece = EmptySquare;
5057
5058     if (from_piece == EmptySquare) return FALSE;
5059
5060     white_piece = (int)from_piece >= (int)WhitePawn &&
5061       (int)from_piece < (int)BlackPawn; /* [HGM] can be > King! */
5062
5063     switch (gameMode) {
5064       case PlayFromGameFile:
5065       case AnalyzeFile:
5066       case TwoMachinesPlay:
5067       case EndOfGame:
5068         return FALSE;
5069
5070       case IcsObserving:
5071       case IcsIdle:
5072         return FALSE;
5073
5074       case MachinePlaysWhite:
5075       case IcsPlayingBlack:
5076         if (appData.zippyPlay) return FALSE;
5077         if (white_piece) {
5078             DisplayMoveError(_("You are playing Black"));
5079             return FALSE;
5080         }
5081         break;
5082
5083       case MachinePlaysBlack:
5084       case IcsPlayingWhite:
5085         if (appData.zippyPlay) return FALSE;
5086         if (!white_piece) {
5087             DisplayMoveError(_("You are playing White"));
5088             return FALSE;
5089         }
5090         break;
5091
5092       case EditGame:
5093         if (!white_piece && WhiteOnMove(currentMove)) {
5094             DisplayMoveError(_("It is White's turn"));
5095             return FALSE;
5096         }
5097         if (white_piece && !WhiteOnMove(currentMove)) {
5098             DisplayMoveError(_("It is Black's turn"));
5099             return FALSE;
5100         }
5101         if (cmailMsgLoaded && (currentMove < cmailOldMove)) {
5102             /* Editing correspondence game history */
5103             /* Could disallow this or prompt for confirmation */
5104             cmailOldMove = -1;
5105         }
5106         if (currentMove < forwardMostMove) {
5107             /* Discarding moves */
5108             /* Could prompt for confirmation here,
5109                but I don't think that's such a good idea */
5110             forwardMostMove = currentMove;
5111         }
5112         break;
5113
5114       case BeginningOfGame:
5115         if (appData.icsActive) return FALSE;
5116         if (!appData.noChessProgram) {
5117             if (!white_piece) {
5118                 DisplayMoveError(_("You are playing White"));
5119                 return FALSE;
5120             }
5121         }
5122         break;
5123
5124       case Training:
5125         if (!white_piece && WhiteOnMove(currentMove)) {
5126             DisplayMoveError(_("It is White's turn"));
5127             return FALSE;
5128         }
5129         if (white_piece && !WhiteOnMove(currentMove)) {
5130             DisplayMoveError(_("It is Black's turn"));
5131             return FALSE;
5132         }
5133         break;
5134
5135       default:
5136       case IcsExamining:
5137         break;
5138     }
5139     if (currentMove != forwardMostMove && gameMode != AnalyzeMode
5140         && gameMode != AnalyzeFile && gameMode != Training) {
5141         DisplayMoveError(_("Displayed position is not current"));
5142         return FALSE;
5143     }
5144     return TRUE;
5145 }
5146
5147 FILE *lastLoadGameFP = NULL, *lastLoadPositionFP = NULL;
5148 int lastLoadGameNumber = 0, lastLoadPositionNumber = 0;
5149 int lastLoadGameUseList = FALSE;
5150 char lastLoadGameTitle[MSG_SIZ], lastLoadPositionTitle[MSG_SIZ];
5151 ChessMove lastLoadGameStart = (ChessMove) 0;
5152
5153 ChessMove
5154 UserMoveTest(fromX, fromY, toX, toY, promoChar, captureOwn)
5155      int fromX, fromY, toX, toY;
5156      int promoChar;
5157      Boolean captureOwn;
5158 {
5159     ChessMove moveType;
5160     ChessSquare pdown, pup;
5161
5162     /* Check if the user is playing in turn.  This is complicated because we
5163        let the user "pick up" a piece before it is his turn.  So the piece he
5164        tried to pick up may have been captured by the time he puts it down!
5165        Therefore we use the color the user is supposed to be playing in this
5166        test, not the color of the piece that is currently on the starting
5167        square---except in EditGame mode, where the user is playing both
5168        sides; fortunately there the capture race can't happen.  (It can
5169        now happen in IcsExamining mode, but that's just too bad.  The user
5170        will get a somewhat confusing message in that case.)
5171        */
5172
5173     switch (gameMode) {
5174       case PlayFromGameFile:
5175       case AnalyzeFile:
5176       case TwoMachinesPlay:
5177       case EndOfGame:
5178       case IcsObserving:
5179       case IcsIdle:
5180         /* We switched into a game mode where moves are not accepted,
5181            perhaps while the mouse button was down. */
5182         return ImpossibleMove;
5183
5184       case MachinePlaysWhite:
5185         /* User is moving for Black */
5186         if (WhiteOnMove(currentMove)) {
5187             DisplayMoveError(_("It is White's turn"));
5188             return ImpossibleMove;
5189         }
5190         break;
5191
5192       case MachinePlaysBlack:
5193         /* User is moving for White */
5194         if (!WhiteOnMove(currentMove)) {
5195             DisplayMoveError(_("It is Black's turn"));
5196             return ImpossibleMove;
5197         }
5198         break;
5199
5200       case EditGame:
5201       case IcsExamining:
5202       case BeginningOfGame:
5203       case AnalyzeMode:
5204       case Training:
5205         if ((int) boards[currentMove][fromY][fromX] >= (int) BlackPawn &&
5206             (int) boards[currentMove][fromY][fromX] < (int) EmptySquare) {
5207             /* User is moving for Black */
5208             if (WhiteOnMove(currentMove)) {
5209                 DisplayMoveError(_("It is White's turn"));
5210                 return ImpossibleMove;
5211             }
5212         } else {
5213             /* User is moving for White */
5214             if (!WhiteOnMove(currentMove)) {
5215                 DisplayMoveError(_("It is Black's turn"));
5216                 return ImpossibleMove;
5217             }
5218         }
5219         break;
5220
5221       case IcsPlayingBlack:
5222         /* User is moving for Black */
5223         if (WhiteOnMove(currentMove)) {
5224             if (!appData.premove) {
5225                 DisplayMoveError(_("It is White's turn"));
5226             } else if (toX >= 0 && toY >= 0) {
5227                 premoveToX = toX;
5228                 premoveToY = toY;
5229                 premoveFromX = fromX;
5230                 premoveFromY = fromY;
5231                 premovePromoChar = promoChar;
5232                 gotPremove = 1;
5233                 if (appData.debugMode)
5234                     fprintf(debugFP, "Got premove: fromX %d,"
5235                             "fromY %d, toX %d, toY %d\n",
5236                             fromX, fromY, toX, toY);
5237             }
5238             return ImpossibleMove;
5239         }
5240         break;
5241
5242       case IcsPlayingWhite:
5243         /* User is moving for White */
5244         if (!WhiteOnMove(currentMove)) {
5245             if (!appData.premove) {
5246                 DisplayMoveError(_("It is Black's turn"));
5247             } else if (toX >= 0 && toY >= 0) {
5248                 premoveToX = toX;
5249                 premoveToY = toY;
5250                 premoveFromX = fromX;
5251                 premoveFromY = fromY;
5252                 premovePromoChar = promoChar;
5253                 gotPremove = 1;
5254                 if (appData.debugMode)
5255                     fprintf(debugFP, "Got premove: fromX %d,"
5256                             "fromY %d, toX %d, toY %d\n",
5257                             fromX, fromY, toX, toY);
5258             }
5259             return ImpossibleMove;
5260         }
5261         break;
5262
5263       default:
5264         break;
5265
5266       case EditPosition:
5267         /* EditPosition, empty square, or different color piece;
5268            click-click move is possible */
5269         if (toX == -2 || toY == -2) {
5270             boards[0][fromY][fromX] = EmptySquare;
5271             return AmbiguousMove;
5272         } else if (toX >= 0 && toY >= 0) {
5273             boards[0][toY][toX] = boards[0][fromY][fromX];
5274             boards[0][fromY][fromX] = EmptySquare;
5275             return AmbiguousMove;
5276         }
5277         return ImpossibleMove;
5278     }
5279
5280     if(toX < 0 || toY < 0) return ImpossibleMove;
5281     pdown = boards[currentMove][fromY][fromX];
5282     pup = boards[currentMove][toY][toX];
5283
5284     /* [HGM] If move started in holdings, it means a drop */
5285     if( fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) {
5286          if( pup != EmptySquare ) return ImpossibleMove;
5287          if(appData.testLegality) {
5288              /* it would be more logical if LegalityTest() also figured out
5289               * which drops are legal. For now we forbid pawns on back rank.
5290               * Shogi is on its own here...
5291               */
5292              if( (pdown == WhitePawn || pdown == BlackPawn) &&
5293                  (toY == 0 || toY == BOARD_HEIGHT -1 ) )
5294                  return(ImpossibleMove); /* no pawn drops on 1st/8th */
5295          }
5296          return WhiteDrop; /* Not needed to specify white or black yet */
5297     }
5298
5299     userOfferedDraw = FALSE;
5300
5301     /* [HGM] always test for legality, to get promotion info */
5302     moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
5303                           epStatus[currentMove], castlingRights[currentMove],
5304                                          fromY, fromX, toY, toX, promoChar);
5305     /* [HGM] but possibly ignore an IllegalMove result */
5306     if (appData.testLegality) {
5307         if (moveType == IllegalMove || moveType == ImpossibleMove) {
5308             DisplayMoveError(_("Illegal move"));
5309             return ImpossibleMove;
5310         }
5311     }
5312
5313     return moveType;
5314     /* [HGM] <popupFix> in stead of calling FinishMove directly, this
5315        function is made into one that returns an OK move type if FinishMove
5316        should be called. This to give the calling driver routine the
5317        opportunity to finish the userMove input with a promotion popup,
5318        without bothering the user with this for invalid or illegal moves */
5319
5320 /*    FinishMove(moveType, fromX, fromY, toX, toY, promoChar); */
5321 }
5322
5323 /* Common tail of UserMoveEvent and DropMenuEvent */
5324 int
5325 FinishMove(moveType, fromX, fromY, toX, toY, promoChar)
5326      ChessMove moveType;
5327      int fromX, fromY, toX, toY;
5328      /*char*/int promoChar;
5329 {
5330     char *bookHit = 0;
5331
5332     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) && promoChar != NULLCHAR) {
5333         // [HGM] superchess: suppress promotions to non-available piece
5334         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
5335         if(WhiteOnMove(currentMove)) {
5336             if(!boards[currentMove][k][BOARD_WIDTH-2]) return 0;
5337         } else {
5338             if(!boards[currentMove][BOARD_HEIGHT-1-k][1]) return 0;
5339         }
5340     }
5341
5342     /* [HGM] <popupFix> kludge to avoid having to know the exact promotion
5343        move type in caller when we know the move is a legal promotion */
5344     if(moveType == NormalMove && promoChar)
5345         moveType = PromoCharToMoveType(WhiteOnMove(currentMove), promoChar);
5346
5347     /* [HGM] convert drag-and-drop piece drops to standard form */
5348     if( fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) {
5349          moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
5350            if(appData.debugMode) fprintf(debugFP, "Drop move %d, curr=%d, x=%d,y=%d, p=%d\n",
5351                 moveType, currentMove, fromX, fromY, boards[currentMove][fromY][fromX]);
5352            // holdings might not be sent yet in ICS play; we have to figure out which piece belongs here
5353            if(fromX == 0) fromY = BOARD_HEIGHT-1 - fromY; // black holdings upside-down
5354            fromX = fromX ? WhitePawn : BlackPawn; // first piece type in selected holdings
5355            while(PieceToChar(fromX) == '.' || PieceToNumber(fromX) != fromY && fromX != (int) EmptySquare) fromX++;
5356          fromY = DROP_RANK;
5357     }
5358
5359     /* [HGM] <popupFix> The following if has been moved here from
5360        UserMoveEvent(). Because it seemed to belong here (why not allow
5361        piece drops in training games?), and because it can only be
5362        performed after it is known to what we promote. */
5363     if (gameMode == Training) {
5364       /* compare the move played on the board to the next move in the
5365        * game. If they match, display the move and the opponent's response.
5366        * If they don't match, display an error message.
5367        */
5368       int saveAnimate;
5369       Board testBoard; char testRights[BOARD_SIZE]; char testStatus;
5370       CopyBoard(testBoard, boards[currentMove]);
5371       ApplyMove(fromX, fromY, toX, toY, promoChar, testBoard, testRights, &testStatus);
5372
5373       if (CompareBoards(testBoard, boards[currentMove+1])) {
5374         ForwardInner(currentMove+1);
5375
5376         /* Autoplay the opponent's response.
5377          * if appData.animate was TRUE when Training mode was entered,
5378          * the response will be animated.
5379          */
5380         saveAnimate = appData.animate;
5381         appData.animate = animateTraining;
5382         ForwardInner(currentMove+1);
5383         appData.animate = saveAnimate;
5384
5385         /* check for the end of the game */
5386         if (currentMove >= forwardMostMove) {
5387           gameMode = PlayFromGameFile;
5388           ModeHighlight();
5389           SetTrainingModeOff();
5390           DisplayInformation(_("End of game"));
5391         }
5392       } else {
5393         DisplayError(_("Incorrect move"), 0);
5394       }
5395       return 1;
5396     }
5397
5398   /* Ok, now we know that the move is good, so we can kill
5399      the previous line in Analysis Mode */
5400   if (gameMode == AnalyzeMode && currentMove < forwardMostMove) {
5401     forwardMostMove = currentMove;
5402   }
5403
5404   /* If we need the chess program but it's dead, restart it */
5405   ResurrectChessProgram();
5406
5407   /* A user move restarts a paused game*/
5408   if (pausing)
5409     PauseEvent();
5410
5411   thinkOutput[0] = NULLCHAR;
5412
5413   MakeMove(fromX, fromY, toX, toY, promoChar); /*updates forwardMostMove*/
5414
5415   if (gameMode == BeginningOfGame) {
5416     if (appData.noChessProgram) {
5417       gameMode = EditGame;
5418       SetGameInfo();
5419     } else {
5420       char buf[MSG_SIZ];
5421       gameMode = MachinePlaysBlack;
5422       StartClocks();
5423       SetGameInfo();
5424       sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
5425       DisplayTitle(buf);
5426       if (first.sendName) {
5427         sprintf(buf, "name %s\n", gameInfo.white);
5428         SendToProgram(buf, &first);
5429       }
5430       StartClocks();
5431     }
5432     ModeHighlight();
5433   }
5434
5435   /* Relay move to ICS or chess engine */
5436   if (appData.icsActive) {
5437     if (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
5438         gameMode == IcsExamining) {
5439       SendMoveToICS(moveType, fromX, fromY, toX, toY);
5440       ics_user_moved = 1;
5441     }
5442   } else {
5443     if (first.sendTime && (gameMode == BeginningOfGame ||
5444                            gameMode == MachinePlaysWhite ||
5445                            gameMode == MachinePlaysBlack)) {
5446       SendTimeRemaining(&first, gameMode != MachinePlaysBlack);
5447     }
5448     if (gameMode != EditGame && gameMode != PlayFromGameFile) {
5449          // [HGM] book: if program might be playing, let it use book
5450         bookHit = SendMoveToBookUser(forwardMostMove-1, &first, FALSE);
5451         first.maybeThinking = TRUE;
5452     } else SendMoveToProgram(forwardMostMove-1, &first);
5453     if (currentMove == cmailOldMove + 1) {
5454       cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
5455     }
5456   }
5457
5458   ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
5459
5460   switch (gameMode) {
5461   case EditGame:
5462     switch (MateTest(boards[currentMove], PosFlags(currentMove),
5463                      EP_UNKNOWN, castlingRights[currentMove]) ) {
5464     case MT_NONE:
5465     case MT_CHECK:
5466       break;
5467     case MT_CHECKMATE:
5468     case MT_STAINMATE:
5469       if (WhiteOnMove(currentMove)) {
5470         GameEnds(BlackWins, "Black mates", GE_PLAYER);
5471       } else {
5472         GameEnds(WhiteWins, "White mates", GE_PLAYER);
5473       }
5474       break;
5475     case MT_STALEMATE:
5476       GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
5477       break;
5478     }
5479     break;
5480
5481   case MachinePlaysBlack:
5482   case MachinePlaysWhite:
5483     /* disable certain menu options while machine is thinking */
5484     SetMachineThinkingEnables();
5485     break;
5486
5487   default:
5488     break;
5489   }
5490
5491   if(bookHit) { // [HGM] book: simulate book reply
5492         static char bookMove[MSG_SIZ]; // a bit generous?
5493
5494         programStats.nodes = programStats.depth = programStats.time =
5495         programStats.score = programStats.got_only_move = 0;
5496         sprintf(programStats.movelist, "%s (xbook)", bookHit);
5497
5498         strcpy(bookMove, "move ");
5499         strcat(bookMove, bookHit);
5500         HandleMachineMove(bookMove, &first);
5501   }
5502   return 1;
5503 }
5504
5505 void
5506 UserMoveEvent(fromX, fromY, toX, toY, promoChar)
5507      int fromX, fromY, toX, toY;
5508      int promoChar;
5509 {
5510     /* [HGM] This routine was added to allow calling of its two logical
5511        parts from other modules in the old way. Before, UserMoveEvent()
5512        automatically called FinishMove() if the move was OK, and returned
5513        otherwise. I separated the two, in order to make it possible to
5514        slip a promotion popup in between. But that it always needs two
5515        calls, to the first part, (now called UserMoveTest() ), and to
5516        FinishMove if the first part succeeded. Calls that do not need
5517        to do anything in between, can call this routine the old way.
5518     */
5519     ChessMove moveType = UserMoveTest(fromX, fromY, toX, toY, promoChar, FALSE);
5520 if(appData.debugMode) fprintf(debugFP, "moveType 4 = %d, promochar = %x\n", moveType, promoChar);
5521     if(moveType == AmbiguousMove)
5522         DrawPosition(FALSE, boards[currentMove]);
5523     else if(moveType != ImpossibleMove && moveType != Comment)
5524         FinishMove(moveType, fromX, fromY, toX, toY, promoChar);
5525 }
5526
5527 void LeftClick(ClickType clickType, int xPix, int yPix)
5528 {
5529     int x, y;
5530     Boolean saveAnimate;
5531     static int second = 0, promotionChoice = 0;
5532     char promoChoice = NULLCHAR;
5533
5534     if (clickType == Press) ErrorPopDown();
5535
5536     x = EventToSquare(xPix, BOARD_WIDTH);
5537     y = EventToSquare(yPix, BOARD_HEIGHT);
5538     if (!flipView && y >= 0) {
5539         y = BOARD_HEIGHT - 1 - y;
5540     }
5541     if (flipView && x >= 0) {
5542         x = BOARD_WIDTH - 1 - x;
5543     }
5544
5545     if(promotionChoice) { // we are waiting for a click to indicate promotion piece
5546         if(clickType == Release) return; // ignore upclick of click-click destination
5547         promotionChoice = FALSE; // only one chance: if click not OK it is interpreted as cancel
5548         if(appData.debugMode) fprintf(debugFP, "promotion click, x=%d, y=%d\n", x, y);
5549         if(gameInfo.holdingsWidth &&
5550                 (WhiteOnMove(currentMove)
5551                         ? x == BOARD_WIDTH-1 && y < gameInfo.holdingsSize && y > 0
5552                         : x == 0 && y >= BOARD_HEIGHT - gameInfo.holdingsSize && y < BOARD_HEIGHT-1) ) {
5553             // click in right holdings, for determining promotion piece
5554             ChessSquare p = boards[currentMove][y][x];
5555             if(appData.debugMode) fprintf(debugFP, "square contains %d\n", (int)p);
5556             if(p != EmptySquare) {
5557                 FinishMove(NormalMove, fromX, fromY, toX, toY, ToLower(PieceToChar(p)));
5558                 fromX = fromY = -1;
5559                 return;
5560             }
5561         }
5562         DrawPosition(FALSE, boards[currentMove]);
5563         return;
5564     }
5565
5566     /* [HGM] holdings: next 5 lines: ignore all clicks between board and holdings */
5567     if(clickType == Press
5568             && ( x == BOARD_LEFT-1 || x == BOARD_RGHT
5569               || x == BOARD_LEFT-2 && y < BOARD_HEIGHT-gameInfo.holdingsSize
5570               || x == BOARD_RGHT+1 && y >= gameInfo.holdingsSize) )
5571         return;
5572
5573     if (fromX == -1) {
5574         if (clickType == Press) {
5575             /* First square */
5576             if (OKToStartUserMove(x, y)) {
5577                 fromX = x;
5578                 fromY = y;
5579                 second = 0;
5580                 DragPieceBegin(xPix, yPix);
5581                 if (appData.highlightDragging) {
5582                     SetHighlights(x, y, -1, -1);
5583                 }
5584             }
5585         }
5586         return;
5587     }
5588
5589     /* fromX != -1 */
5590     if (clickType == Press && gameMode != EditPosition) {
5591         ChessSquare fromP;
5592         ChessSquare toP;
5593         int frc;
5594
5595         // ignore off-board to clicks
5596         if(y < 0 || x < 0) return;
5597
5598         /* Check if clicking again on the same color piece */
5599         fromP = boards[currentMove][fromY][fromX];
5600         toP = boards[currentMove][y][x];
5601         frc = gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom;
5602         if ((WhitePawn <= fromP && fromP <= WhiteKing &&
5603              WhitePawn <= toP && toP <= WhiteKing &&
5604              !(fromP == WhiteKing && toP == WhiteRook && frc) &&
5605              !(fromP == WhiteRook && toP == WhiteKing && frc)) ||
5606             (BlackPawn <= fromP && fromP <= BlackKing &&
5607              BlackPawn <= toP && toP <= BlackKing &&
5608              !(fromP == BlackRook && toP == BlackKing && frc) && // allow also RxK as FRC castling
5609              !(fromP == BlackKing && toP == BlackRook && frc))) {
5610             /* Clicked again on same color piece -- changed his mind */
5611             second = (x == fromX && y == fromY);
5612             if (appData.highlightDragging) {
5613                 SetHighlights(x, y, -1, -1);
5614             } else {
5615                 ClearHighlights();
5616             }
5617             if (OKToStartUserMove(x, y)) {
5618                 fromX = x;
5619                 fromY = y;
5620                 DragPieceBegin(xPix, yPix);
5621             }
5622             return;
5623         }
5624         // ignore clicks on holdings
5625         if(x < BOARD_LEFT || x >= BOARD_RGHT) return;
5626     }
5627
5628     if (clickType == Release && x == fromX && y == fromY) {
5629         DragPieceEnd(xPix, yPix);
5630         if (appData.animateDragging) {
5631             /* Undo animation damage if any */
5632             DrawPosition(FALSE, NULL);
5633         }
5634         if (second) {
5635             /* Second up/down in same square; just abort move */
5636             second = 0;
5637             fromX = fromY = -1;
5638             ClearHighlights();
5639             gotPremove = 0;
5640             ClearPremoveHighlights();
5641         } else {
5642             /* First upclick in same square; start click-click mode */
5643             SetHighlights(x, y, -1, -1);
5644         }
5645         return;
5646     }
5647
5648     /* we now have a different from- and (possibly off-board) to-square */
5649     /* Completed move */
5650     toX = x;
5651     toY = y;
5652     saveAnimate = appData.animate;
5653     if (clickType == Press) {
5654         /* Finish clickclick move */
5655         if (appData.animate || appData.highlightLastMove) {
5656             SetHighlights(fromX, fromY, toX, toY);
5657         } else {
5658             ClearHighlights();
5659         }
5660     } else {
5661         /* Finish drag move */
5662         if (appData.highlightLastMove) {
5663             SetHighlights(fromX, fromY, toX, toY);
5664         } else {
5665             ClearHighlights();
5666         }
5667         DragPieceEnd(xPix, yPix);
5668         /* Don't animate move and drag both */
5669         appData.animate = FALSE;
5670     }
5671
5672     // moves into holding are invalid for now (later perhaps allow in EditPosition)
5673     if(x >= 0 && x < BOARD_LEFT || x >= BOARD_RGHT) {
5674         ClearHighlights();
5675         fromX = fromY = -1;
5676         DrawPosition(TRUE, NULL);
5677         return;
5678     }
5679
5680     // off-board moves should not be highlighted
5681     if(x < 0 || x < 0) ClearHighlights();
5682
5683     if (HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice)) {
5684         SetHighlights(fromX, fromY, toX, toY);
5685         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
5686             // [HGM] super: promotion to captured piece selected from holdings
5687             ChessSquare p = boards[currentMove][fromY][fromX], q = boards[currentMove][toY][toX];
5688             promotionChoice = TRUE;
5689             // kludge follows to temporarily execute move on display, without promoting yet
5690             boards[currentMove][fromY][fromX] = EmptySquare; // move Pawn to 8th rank
5691             boards[currentMove][toY][toX] = p;
5692             DrawPosition(FALSE, boards[currentMove]);
5693             boards[currentMove][fromY][fromX] = p; // take back, but display stays
5694             boards[currentMove][toY][toX] = q;
5695             DisplayMessage("Click in holdings to choose piece", "");
5696             return;
5697         }
5698         PromotionPopUp();
5699     } else {
5700         UserMoveEvent(fromX, fromY, toX, toY, promoChoice);
5701         if (!appData.highlightLastMove || gotPremove) ClearHighlights();
5702         if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
5703         fromX = fromY = -1;
5704     }
5705     appData.animate = saveAnimate;
5706     if (appData.animate || appData.animateDragging) {
5707         /* Undo animation damage if needed */
5708         DrawPosition(FALSE, NULL);
5709     }
5710 }
5711
5712 void SendProgramStatsToFrontend( ChessProgramState * cps, ChessProgramStats * cpstats )
5713 {
5714 //    char * hint = lastHint;
5715     FrontEndProgramStats stats;
5716
5717     stats.which = cps == &first ? 0 : 1;
5718     stats.depth = cpstats->depth;
5719     stats.nodes = cpstats->nodes;
5720     stats.score = cpstats->score;
5721     stats.time = cpstats->time;
5722     stats.pv = cpstats->movelist;
5723     stats.hint = lastHint;
5724     stats.an_move_index = 0;
5725     stats.an_move_count = 0;
5726
5727     if( gameMode == AnalyzeMode || gameMode == AnalyzeFile ) {
5728         stats.hint = cpstats->move_name;
5729         stats.an_move_index = cpstats->nr_moves - cpstats->moves_left;
5730         stats.an_move_count = cpstats->nr_moves;
5731     }
5732
5733     SetProgramStats( &stats );
5734 }
5735
5736 char *SendMoveToBookUser(int moveNr, ChessProgramState *cps, int initial)
5737 {   // [HGM] book: this routine intercepts moves to simulate book replies
5738     char *bookHit = NULL;
5739
5740     //first determine if the incoming move brings opponent into his book
5741     if(appData.usePolyglotBook && (cps == &first ? !appData.firstHasOwnBookUCI : !appData.secondHasOwnBookUCI))
5742         bookHit = ProbeBook(moveNr+1, appData.polyglotBook); // returns move
5743     if(appData.debugMode) fprintf(debugFP, "book hit = %s\n", bookHit ? bookHit : "(NULL)");
5744     if(bookHit != NULL && !cps->bookSuspend) {
5745         // make sure opponent is not going to reply after receiving move to book position
5746         SendToProgram("force\n", cps);
5747         cps->bookSuspend = TRUE; // flag indicating it has to be restarted
5748     }
5749     if(!initial) SendMoveToProgram(moveNr, cps); // with hit on initial position there is no move
5750     // now arrange restart after book miss
5751     if(bookHit) {
5752         // after a book hit we never send 'go', and the code after the call to this routine
5753         // has '&& !bookHit' added to suppress potential sending there (based on 'firstMove').
5754         char buf[MSG_SIZ];
5755         if (cps->useUsermove) sprintf(buf, "usermove "); // sorry, no SAN yet :(
5756         sprintf(buf, "%s\n", bookHit); // force book move into program supposed to play it
5757         SendToProgram(buf, cps);
5758         if(!initial) firstMove = FALSE; // normally we would clear the firstMove condition after return & sending 'go'
5759     } else if(initial) { // 'go' was needed irrespective of firstMove, and it has to be done in this routine
5760         SendToProgram("go\n", cps);
5761         cps->bookSuspend = FALSE; // after a 'go' we are never suspended
5762     } else { // 'go' might be sent based on 'firstMove' after this routine returns
5763         if(cps->bookSuspend && !firstMove) // 'go' needed, and it will not be done after we return
5764             SendToProgram("go\n", cps);
5765         cps->bookSuspend = FALSE; // anyhow, we will not be suspended after a miss
5766     }
5767     return bookHit; // notify caller of hit, so it can take action to send move to opponent
5768 }
5769
5770 char *savedMessage;
5771 ChessProgramState *savedState;
5772 void DeferredBookMove(void)
5773 {
5774         if(savedState->lastPing != savedState->lastPong)
5775                     ScheduleDelayedEvent(DeferredBookMove, 10);
5776         else
5777         HandleMachineMove(savedMessage, savedState);
5778 }
5779
5780 void
5781 HandleMachineMove(message, cps)
5782      char *message;
5783      ChessProgramState *cps;
5784 {
5785     char machineMove[MSG_SIZ], buf1[MSG_SIZ*10], buf2[MSG_SIZ];
5786     char realname[MSG_SIZ];
5787     int fromX, fromY, toX, toY;
5788     ChessMove moveType;
5789     char promoChar;
5790     char *p;
5791     int machineWhite;
5792     char *bookHit;
5793
5794 FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book hit
5795     /*
5796      * Kludge to ignore BEL characters
5797      */
5798     while (*message == '\007') message++;
5799
5800     /*
5801      * [HGM] engine debug message: ignore lines starting with '#' character
5802      */
5803     if(cps->debug && *message == '#') return;
5804
5805     /*
5806      * Look for book output
5807      */
5808     if (cps == &first && bookRequested) {
5809         if (message[0] == '\t' || message[0] == ' ') {
5810             /* Part of the book output is here; append it */
5811             strcat(bookOutput, message);
5812             strcat(bookOutput, "  \n");
5813             return;
5814         } else if (bookOutput[0] != NULLCHAR) {
5815             /* All of book output has arrived; display it */
5816             char *p = bookOutput;
5817             while (*p != NULLCHAR) {
5818                 if (*p == '\t') *p = ' ';
5819                 p++;
5820             }
5821             DisplayInformation(bookOutput);
5822             bookRequested = FALSE;
5823             /* Fall through to parse the current output */
5824         }
5825     }
5826
5827     /*
5828      * Look for machine move.
5829      */
5830     if ((sscanf(message, "%s %s %s", buf1, buf2, machineMove) == 3 && strcmp(buf2, "...") == 0) ||
5831         (sscanf(message, "%s %s", buf1, machineMove) == 2 && strcmp(buf1, "move") == 0))
5832     {
5833         /* This method is only useful on engines that support ping */
5834         if (cps->lastPing != cps->lastPong) {
5835           if (gameMode == BeginningOfGame) {
5836             /* Extra move from before last new; ignore */
5837             if (appData.debugMode) {
5838                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
5839             }
5840           } else {
5841             if (appData.debugMode) {
5842                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
5843                         cps->which, gameMode);
5844             }
5845
5846             SendToProgram("undo\n", cps);
5847           }
5848           return;
5849         }
5850
5851         switch (gameMode) {
5852           case BeginningOfGame:
5853             /* Extra move from before last reset; ignore */
5854             if (appData.debugMode) {
5855                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
5856             }
5857             return;
5858
5859           case EndOfGame:
5860           case IcsIdle:
5861           default:
5862             /* Extra move after we tried to stop.  The mode test is
5863                not a reliable way of detecting this problem, but it's
5864                the best we can do on engines that don't support ping.
5865             */
5866             if (appData.debugMode) {
5867                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
5868                         cps->which, gameMode);
5869             }
5870             SendToProgram("undo\n", cps);
5871             return;
5872
5873           case MachinePlaysWhite:
5874           case IcsPlayingWhite:
5875             machineWhite = TRUE;
5876             break;
5877
5878           case MachinePlaysBlack:
5879           case IcsPlayingBlack:
5880             machineWhite = FALSE;
5881             break;
5882
5883           case TwoMachinesPlay:
5884             machineWhite = (cps->twoMachinesColor[0] == 'w');
5885             break;
5886         }
5887         if (WhiteOnMove(forwardMostMove) != machineWhite) {
5888             if (appData.debugMode) {
5889                 fprintf(debugFP,
5890                         "Ignoring move out of turn by %s, gameMode %d"
5891                         ", forwardMost %d\n",
5892                         cps->which, gameMode, forwardMostMove);
5893             }
5894             return;
5895         }
5896
5897     if (appData.debugMode) { int f = forwardMostMove;
5898         fprintf(debugFP, "machine move %d, castling = %d %d %d %d %d %d\n", f,
5899                 castlingRights[f][0],castlingRights[f][1],castlingRights[f][2],castlingRights[f][3],castlingRights[f][4],castlingRights[f][5]);
5900     }
5901         if(cps->alphaRank) AlphaRank(machineMove, 4);
5902         if (!ParseOneMove(machineMove, forwardMostMove, &moveType,
5903                               &fromX, &fromY, &toX, &toY, &promoChar)) {
5904             /* Machine move could not be parsed; ignore it. */
5905             sprintf(buf1, _("Illegal move \"%s\" from %s machine"),
5906                     machineMove, cps->which);
5907             DisplayError(buf1, 0);
5908             sprintf(buf1, "Xboard: Forfeit due to invalid move: %s (%c%c%c%c) res=%d",
5909                     machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, moveType);
5910             if (gameMode == TwoMachinesPlay) {
5911               GameEnds(machineWhite ? BlackWins : WhiteWins,
5912                        buf1, GE_XBOARD);
5913             }
5914             return;
5915         }
5916
5917         /* [HGM] Apparently legal, but so far only tested with EP_UNKOWN */
5918         /* So we have to redo legality test with true e.p. status here,  */
5919         /* to make sure an illegal e.p. capture does not slip through,   */
5920         /* to cause a forfeit on a justified illegal-move complaint      */
5921         /* of the opponent.                                              */
5922         if( gameMode==TwoMachinesPlay && appData.testLegality
5923             && fromY != DROP_RANK /* [HGM] temporary; should still add legality test for drops */
5924                                                               ) {
5925            ChessMove moveType;
5926            moveType = LegalityTest(boards[forwardMostMove], PosFlags(forwardMostMove),
5927                         epStatus[forwardMostMove], castlingRights[forwardMostMove],
5928                              fromY, fromX, toY, toX, promoChar);
5929             if (appData.debugMode) {
5930                 int i;
5931                 for(i=0; i< nrCastlingRights; i++) fprintf(debugFP, "(%d,%d) ",
5932                     castlingRights[forwardMostMove][i], castlingRank[i]);
5933                 fprintf(debugFP, "castling rights\n");
5934             }
5935             if(moveType == IllegalMove) {
5936                 sprintf(buf1, "Xboard: Forfeit due to illegal move: %s (%c%c%c%c)%c",
5937                         machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, 0);
5938                 GameEnds(machineWhite ? BlackWins : WhiteWins,
5939                            buf1, GE_XBOARD);
5940                 return;
5941            } else if(gameInfo.variant != VariantFischeRandom && gameInfo.variant != VariantCapaRandom)
5942            /* [HGM] Kludge to handle engines that send FRC-style castling
5943               when they shouldn't (like TSCP-Gothic) */
5944            switch(moveType) {
5945              case WhiteASideCastleFR:
5946              case BlackASideCastleFR:
5947                toX+=2;
5948                currentMoveString[2]++;
5949                break;
5950              case WhiteHSideCastleFR:
5951              case BlackHSideCastleFR:
5952                toX--;
5953                currentMoveString[2]--;
5954                break;
5955              default: ; // nothing to do, but suppresses warning of pedantic compilers
5956            }
5957         }
5958         hintRequested = FALSE;
5959         lastHint[0] = NULLCHAR;
5960         bookRequested = FALSE;
5961         /* Program may be pondering now */
5962         cps->maybeThinking = TRUE;
5963         if (cps->sendTime == 2) cps->sendTime = 1;
5964         if (cps->offeredDraw) cps->offeredDraw--;
5965
5966 #if ZIPPY
5967         if ((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack) &&
5968             first.initDone) {
5969           SendMoveToICS(moveType, fromX, fromY, toX, toY);
5970           ics_user_moved = 1;
5971           if(appData.autoKibitz && !appData.icsEngineAnalyze ) { /* [HGM] kibitz: send most-recent PV info to ICS */
5972                 char buf[3*MSG_SIZ];
5973
5974                 sprintf(buf, "kibitz !!! %+.2f/%d (%.2f sec, %u nodes, %.0f knps) PV=%s\n",
5975                         programStats.score / 100.,
5976                         programStats.depth,
5977                         programStats.time / 100.,
5978                         (unsigned int)programStats.nodes,
5979                         (unsigned int)programStats.nodes / (10*abs(programStats.time) + 1.),
5980                         programStats.movelist);
5981                 SendToICS(buf);
5982 if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.nodes, programStats.nodes);
5983           }
5984         }
5985 #endif
5986         /* currentMoveString is set as a side-effect of ParseOneMove */
5987         strcpy(machineMove, currentMoveString);
5988         strcat(machineMove, "\n");
5989         strcpy(moveList[forwardMostMove], machineMove);
5990
5991         /* [AS] Save move info and clear stats for next move */
5992         pvInfoList[ forwardMostMove ].score = programStats.score;
5993         pvInfoList[ forwardMostMove ].depth = programStats.depth;
5994         pvInfoList[ forwardMostMove ].time =  programStats.time; // [HGM] PGNtime: take time from engine stats
5995         ClearProgramStats();
5996         thinkOutput[0] = NULLCHAR;
5997         hiddenThinkOutputState = 0;
5998
5999         MakeMove(fromX, fromY, toX, toY, promoChar);/*updates forwardMostMove*/
6000
6001         /* [AS] Adjudicate game if needed (note: remember that forwardMostMove now points past the last move) */
6002         if( gameMode == TwoMachinesPlay && adjudicateLossThreshold != 0 && forwardMostMove >= adjudicateLossPlies ) {
6003             int count = 0;
6004
6005             while( count < adjudicateLossPlies ) {
6006                 int score = pvInfoList[ forwardMostMove - count - 1 ].score;
6007
6008                 if( count & 1 ) {
6009                     score = -score; /* Flip score for winning side */
6010                 }
6011
6012                 if( score > adjudicateLossThreshold ) {
6013                     break;
6014                 }
6015
6016                 count++;
6017             }
6018
6019             if( count >= adjudicateLossPlies ) {
6020                 ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6021
6022                 GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
6023                     "Xboard adjudication",
6024                     GE_XBOARD );
6025
6026                 return;
6027             }
6028         }
6029
6030         if( gameMode == TwoMachinesPlay ) {
6031           // [HGM] some adjudications useful with buggy engines
6032             int k, count = 0, epFile = epStatus[forwardMostMove]; static int bare = 1;
6033           if(gameInfo.holdingsSize == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
6034
6035
6036             if( appData.testLegality )
6037             {   /* [HGM] Some more adjudications for obstinate engines */
6038                 int NrWN=0, NrBN=0, NrWB=0, NrBB=0, NrWR=0, NrBR=0,
6039                     NrWQ=0, NrBQ=0, NrW=0, NrK=0, bishopsColor = 0,
6040                     NrPieces=0, NrPawns=0, PawnAdvance=0, i, j;
6041                 static int moveCount = 6;
6042                 ChessMove result;
6043                 char *reason = NULL;
6044
6045                 /* Count what is on board. */
6046                 for(i=0; i<BOARD_HEIGHT; i++) for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
6047                 {   ChessSquare p = boards[forwardMostMove][i][j];
6048                     int m=i;
6049
6050                     switch((int) p)
6051                     {   /* count B,N,R and other of each side */
6052                         case WhiteKing:
6053                         case BlackKing:
6054                              NrK++; break; // [HGM] atomic: count Kings
6055                         case WhiteKnight:
6056                              NrWN++; break;
6057                         case WhiteBishop:
6058                         case WhiteFerz:    // [HGM] shatranj: kludge to mke it work in shatranj
6059                              bishopsColor |= 1 << ((i^j)&1);
6060                              NrWB++; break;
6061                         case BlackKnight:
6062                              NrBN++; break;
6063                         case BlackBishop:
6064                         case BlackFerz:    // [HGM] shatranj: kludge to mke it work in shatranj
6065                              bishopsColor |= 1 << ((i^j)&1);
6066                              NrBB++; break;
6067                         case WhiteRook:
6068                              NrWR++; break;
6069                         case BlackRook:
6070                              NrBR++; break;
6071                         case WhiteQueen:
6072                              NrWQ++; break;
6073                         case BlackQueen:
6074                              NrBQ++; break;
6075                         case EmptySquare:
6076                              break;
6077                         case BlackPawn:
6078                              m = 7-i;
6079                         case WhitePawn:
6080                              PawnAdvance += m; NrPawns++;
6081                     }
6082                     NrPieces += (p != EmptySquare);
6083                     NrW += ((int)p < (int)BlackPawn);
6084                     if(gameInfo.variant == VariantXiangqi &&
6085                       (p == WhiteFerz || p == WhiteAlfil || p == BlackFerz || p == BlackAlfil)) {
6086                         NrPieces--; // [HGM] XQ: do not count purely defensive pieces
6087                         NrW -= ((int)p < (int)BlackPawn);
6088                     }
6089                 }
6090
6091                 /* Some material-based adjudications that have to be made before stalemate test */
6092                 if(gameInfo.variant == VariantAtomic && NrK < 2) {
6093                     // [HGM] atomic: stm must have lost his King on previous move, as destroying own K is illegal
6094                      epStatus[forwardMostMove] = EP_CHECKMATE; // make claimable as if stm is checkmated
6095                      if(appData.checkMates) {
6096                          SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets move
6097                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6098                          GameEnds( WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins,
6099                                                         "Xboard adjudication: King destroyed", GE_XBOARD );
6100                          return;
6101                      }
6102                 }
6103
6104                 /* Bare King in Shatranj (loses) or Losers (wins) */
6105                 if( NrW == 1 || NrPieces - NrW == 1) {
6106                   if( gameInfo.variant == VariantLosers) { // [HGM] losers: bare King wins (stm must have it first)
6107                      epStatus[forwardMostMove] = EP_WINS;  // mark as win, so it becomes claimable
6108                      if(appData.checkMates) {
6109                          SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets to see move
6110                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6111                          GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
6112                                                         "Xboard adjudication: Bare king", GE_XBOARD );
6113                          return;
6114                      }
6115                   } else
6116                   if( gameInfo.variant == VariantShatranj && --bare < 0)
6117                   {    /* bare King */
6118                         epStatus[forwardMostMove] = EP_WINS; // make claimable as win for stm
6119                         if(appData.checkMates) {
6120                             /* but only adjudicate if adjudication enabled */
6121                             SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets move
6122                             ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6123                             GameEnds( NrW > 1 ? WhiteWins : NrPieces - NrW > 1 ? BlackWins : GameIsDrawn,
6124                                                         "Xboard adjudication: Bare king", GE_XBOARD );
6125                             return;
6126                         }
6127                   }
6128                 } else bare = 1;
6129
6130
6131             // don't wait for engine to announce game end if we can judge ourselves
6132             switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove), epFile,
6133                                        castlingRights[forwardMostMove]) ) {
6134               case MT_CHECK:
6135                 if(gameInfo.variant == Variant3Check) { // [HGM] 3check: when in check, test if 3rd time
6136                     int i, checkCnt = 0;    // (should really be done by making nr of checks part of game state)
6137                     for(i=forwardMostMove-2; i>=backwardMostMove; i-=2) {
6138                         if(MateTest(boards[i], PosFlags(i), epStatus[i], castlingRights[i]) == MT_CHECK)
6139                             checkCnt++;
6140                         if(checkCnt >= 2) {
6141                             reason = "Xboard adjudication: 3rd check";
6142                             epStatus[forwardMostMove] = EP_CHECKMATE;
6143                             break;
6144                         }
6145                     }
6146                 }
6147               case MT_NONE:
6148               default:
6149                 break;
6150               case MT_STALEMATE:
6151               case MT_STAINMATE:
6152                 reason = "Xboard adjudication: Stalemate";
6153                 if(epStatus[forwardMostMove] != EP_CHECKMATE) { // [HGM] don't touch win through baring or K-capt
6154                     epStatus[forwardMostMove] = EP_STALEMATE;   // default result for stalemate is draw
6155                     if(gameInfo.variant == VariantLosers  || gameInfo.variant == VariantGiveaway) // [HGM] losers:
6156                         epStatus[forwardMostMove] = EP_WINS;    // in these variants stalemated is always a win
6157                     else if(gameInfo.variant == VariantSuicide) // in suicide it depends
6158                         epStatus[forwardMostMove] = NrW == NrPieces-NrW ? EP_STALEMATE :
6159                                                    ((NrW < NrPieces-NrW) != WhiteOnMove(forwardMostMove) ?
6160                                                                         EP_CHECKMATE : EP_WINS);
6161                     else if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantXiangqi)
6162                         epStatus[forwardMostMove] = EP_CHECKMATE; // and in these variants being stalemated loses
6163                 }
6164                 break;
6165               case MT_CHECKMATE:
6166                 reason = "Xboard adjudication: Checkmate";
6167                 epStatus[forwardMostMove] = (gameInfo.variant == VariantLosers ? EP_WINS : EP_CHECKMATE);
6168                 break;
6169             }
6170
6171                 switch(i = epStatus[forwardMostMove]) {
6172                     case EP_STALEMATE:
6173                         result = GameIsDrawn; break;
6174                     case EP_CHECKMATE:
6175                         result = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins; break;
6176                     case EP_WINS:
6177                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins; break;
6178                     default:
6179                         result = (ChessMove) 0;
6180                 }
6181                 if(appData.checkMates && result) { // [HGM] mates: adjudicate finished games if requested
6182                     SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6183                     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6184                     GameEnds( result, reason, GE_XBOARD );
6185                     return;
6186                 }
6187
6188                 /* Next absolutely insufficient mating material. */
6189                 if( NrPieces == 2 || gameInfo.variant != VariantXiangqi &&
6190                                      gameInfo.variant != VariantShatranj && // [HGM] baring will remain possible
6191                         (NrPieces == 3 && NrWN+NrBN+NrWB+NrBB == 1 ||
6192                          NrPieces == NrBB+NrWB+2 && bishopsColor != 3)) // [HGM] all Bishops (Ferz!) same color
6193                 {    /* KBK, KNK, KK of KBKB with like Bishops */
6194
6195                      /* always flag draws, for judging claims */
6196                      epStatus[forwardMostMove] = EP_INSUF_DRAW;
6197
6198                      if(appData.materialDraws) {
6199                          /* but only adjudicate them if adjudication enabled */
6200                          SendToProgram("force\n", cps->other); // suppress reply
6201                          SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see last move */
6202                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6203                          GameEnds( GameIsDrawn, "Xboard adjudication: Insufficient mating material", GE_XBOARD );
6204                          return;
6205                      }
6206                 }
6207
6208                 /* Then some trivial draws (only adjudicate, cannot be claimed) */
6209                 if(NrPieces == 4 &&
6210                    (   NrWR == 1 && NrBR == 1 /* KRKR */
6211                    || NrWQ==1 && NrBQ==1     /* KQKQ */
6212                    || NrWN==2 || NrBN==2     /* KNNK */
6213                    || NrWN+NrWB == 1 && NrBN+NrBB == 1 /* KBKN, KBKB, KNKN */
6214                   ) ) {
6215                      if(--moveCount < 0 && appData.trivialDraws)
6216                      {    /* if the first 3 moves do not show a tactical win, declare draw */
6217                           SendToProgram("force\n", cps->other); // suppress reply
6218                           SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6219                           ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6220                           GameEnds( GameIsDrawn, "Xboard adjudication: Trivial draw", GE_XBOARD );
6221                           return;
6222                      }
6223                 } else moveCount = 6;
6224             }
6225           }
6226
6227           if (appData.debugMode) { int i;
6228             fprintf(debugFP, "repeat test fmm=%d bmm=%d ep=%d, reps=%d\n",
6229                     forwardMostMove, backwardMostMove, epStatus[backwardMostMove],
6230                     appData.drawRepeats);
6231             for( i=forwardMostMove; i>=backwardMostMove; i-- )
6232               fprintf(debugFP, "%d ep=%d\n", i, epStatus[i]);
6233
6234           }
6235
6236                 /* Check for rep-draws */
6237                 count = 0;
6238                 for(k = forwardMostMove-2;
6239                     k>=backwardMostMove && k>=forwardMostMove-100 &&
6240                         epStatus[k] < EP_UNKNOWN &&
6241                         epStatus[k+2] <= EP_NONE && epStatus[k+1] <= EP_NONE;
6242                     k-=2)
6243                 {   int rights=0;
6244                     if(CompareBoards(boards[k], boards[forwardMostMove])) {
6245                         /* compare castling rights */
6246                         if( castlingRights[forwardMostMove][2] != castlingRights[k][2] &&
6247                              (castlingRights[k][0] >= 0 || castlingRights[k][1] >= 0) )
6248                                 rights++; /* King lost rights, while rook still had them */
6249                         if( castlingRights[forwardMostMove][2] >= 0 ) { /* king has rights */
6250                             if( castlingRights[forwardMostMove][0] != castlingRights[k][0] ||
6251                                 castlingRights[forwardMostMove][1] != castlingRights[k][1] )
6252                                    rights++; /* but at least one rook lost them */
6253                         }
6254                         if( castlingRights[forwardMostMove][5] != castlingRights[k][5] &&
6255                              (castlingRights[k][3] >= 0 || castlingRights[k][4] >= 0) )
6256                                 rights++;
6257                         if( castlingRights[forwardMostMove][5] >= 0 ) {
6258                             if( castlingRights[forwardMostMove][3] != castlingRights[k][3] ||
6259                                 castlingRights[forwardMostMove][4] != castlingRights[k][4] )
6260                                    rights++;
6261                         }
6262                         if( rights == 0 && ++count > appData.drawRepeats-2
6263                             && appData.drawRepeats > 1) {
6264                              /* adjudicate after user-specified nr of repeats */
6265                              SendToProgram("force\n", cps->other); // suppress reply
6266                              SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6267                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6268                              if(gameInfo.variant == VariantXiangqi && appData.testLegality) {
6269                                 // [HGM] xiangqi: check for forbidden perpetuals
6270                                 int m, ourPerpetual = 1, hisPerpetual = 1;
6271                                 for(m=forwardMostMove; m>k; m-=2) {
6272                                     if(MateTest(boards[m], PosFlags(m),
6273                                                         EP_NONE, castlingRights[m]) != MT_CHECK)
6274                                         ourPerpetual = 0; // the current mover did not always check
6275                                     if(MateTest(boards[m-1], PosFlags(m-1),
6276                                                         EP_NONE, castlingRights[m-1]) != MT_CHECK)
6277                                         hisPerpetual = 0; // the opponent did not always check
6278                                 }
6279                                 if(appData.debugMode) fprintf(debugFP, "XQ perpetual test, our=%d, his=%d\n",
6280                                                                         ourPerpetual, hisPerpetual);
6281                                 if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit
6282                                     GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
6283                                            "Xboard adjudication: perpetual checking", GE_XBOARD );
6284                                     return;
6285                                 }
6286                                 if(hisPerpetual && !ourPerpetual)   // he is checking us, but did not repeat yet
6287                                     break; // (or we would have caught him before). Abort repetition-checking loop.
6288                                 // Now check for perpetual chases
6289                                 if(!ourPerpetual && !hisPerpetual) { // no perpetual check, test for chase
6290                                     hisPerpetual = PerpetualChase(k, forwardMostMove);
6291                                     ourPerpetual = PerpetualChase(k+1, forwardMostMove);
6292                                     if(ourPerpetual && !hisPerpetual) { // we are actively chasing him: forfeit
6293                                         GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
6294                                                       "Xboard adjudication: perpetual chasing", GE_XBOARD );
6295                                         return;
6296                                     }
6297                                     if(hisPerpetual && !ourPerpetual)   // he is chasing us, but did not repeat yet
6298                                         break; // Abort repetition-checking loop.
6299                                 }
6300                                 // if neither of us is checking or chasing all the time, or both are, it is draw
6301                              }
6302                              GameEnds( GameIsDrawn, "Xboard adjudication: repetition draw", GE_XBOARD );
6303                              return;
6304                         }
6305                         if( rights == 0 && count > 1 ) /* occurred 2 or more times before */
6306                              epStatus[forwardMostMove] = EP_REP_DRAW;
6307                     }
6308                 }
6309
6310                 /* Now we test for 50-move draws. Determine ply count */
6311                 count = forwardMostMove;
6312                 /* look for last irreversble move */
6313                 while( epStatus[count] <= EP_NONE && count > backwardMostMove )
6314                     count--;
6315                 /* if we hit starting position, add initial plies */
6316                 if( count == backwardMostMove )
6317                     count -= initialRulePlies;
6318                 count = forwardMostMove - count;
6319                 if( count >= 100)
6320                          epStatus[forwardMostMove] = EP_RULE_DRAW;
6321                          /* this is used to judge if draw claims are legal */
6322                 if(appData.ruleMoves > 0 && count >= 2*appData.ruleMoves) {
6323                          SendToProgram("force\n", cps->other); // suppress reply
6324                          SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6325                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6326                          GameEnds( GameIsDrawn, "Xboard adjudication: 50-move rule", GE_XBOARD );
6327                          return;
6328                 }
6329
6330                 /* if draw offer is pending, treat it as a draw claim
6331                  * when draw condition present, to allow engines a way to
6332                  * claim draws before making their move to avoid a race
6333                  * condition occurring after their move
6334                  */
6335                 if( cps->other->offeredDraw || cps->offeredDraw ) {
6336                          char *p = NULL;
6337                          if(epStatus[forwardMostMove] == EP_RULE_DRAW)
6338                              p = "Draw claim: 50-move rule";
6339                          if(epStatus[forwardMostMove] == EP_REP_DRAW)
6340                              p = "Draw claim: 3-fold repetition";
6341                          if(epStatus[forwardMostMove] == EP_INSUF_DRAW)
6342                              p = "Draw claim: insufficient mating material";
6343                          if( p != NULL ) {
6344                              SendToProgram("force\n", cps->other); // suppress reply
6345                              SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6346                              GameEnds( GameIsDrawn, p, GE_XBOARD );
6347                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6348                              return;
6349                          }
6350                 }
6351
6352
6353                 if( appData.adjudicateDrawMoves > 0 && forwardMostMove > (2*appData.adjudicateDrawMoves) ) {
6354                     SendToProgram("force\n", cps->other); // suppress reply
6355                     SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6356                     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6357
6358                     GameEnds( GameIsDrawn, "Xboard adjudication: long game", GE_XBOARD );
6359
6360                     return;
6361                 }
6362         }
6363
6364         bookHit = NULL;
6365         if (gameMode == TwoMachinesPlay) {
6366             /* [HGM] relaying draw offers moved to after reception of move */
6367             /* and interpreting offer as claim if it brings draw condition */
6368             if (cps->offeredDraw == 1 && cps->other->sendDrawOffers) {
6369                 SendToProgram("draw\n", cps->other);
6370             }
6371             if (cps->other->sendTime) {
6372                 SendTimeRemaining(cps->other,
6373                                   cps->other->twoMachinesColor[0] == 'w');
6374             }
6375             bookHit = SendMoveToBookUser(forwardMostMove-1, cps->other, FALSE);
6376             if (firstMove && !bookHit) {
6377                 firstMove = FALSE;
6378                 if (cps->other->useColors) {
6379                   SendToProgram(cps->other->twoMachinesColor, cps->other);
6380                 }
6381                 SendToProgram("go\n", cps->other);
6382             }
6383             cps->other->maybeThinking = TRUE;
6384         }
6385
6386         ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6387
6388         if (!pausing && appData.ringBellAfterMoves) {
6389             RingBell();
6390         }
6391
6392         /*
6393          * Reenable menu items that were disabled while
6394          * machine was thinking
6395          */
6396         if (gameMode != TwoMachinesPlay)
6397             SetUserThinkingEnables();
6398
6399         // [HGM] book: after book hit opponent has received move and is now in force mode
6400         // force the book reply into it, and then fake that it outputted this move by jumping
6401         // back to the beginning of HandleMachineMove, with cps toggled and message set to this move
6402         if(bookHit) {
6403                 static char bookMove[MSG_SIZ]; // a bit generous?
6404
6405                 strcpy(bookMove, "move ");
6406                 strcat(bookMove, bookHit);
6407                 message = bookMove;
6408                 cps = cps->other;
6409                 programStats.nodes = programStats.depth = programStats.time =
6410                 programStats.score = programStats.got_only_move = 0;
6411                 sprintf(programStats.movelist, "%s (xbook)", bookHit);
6412
6413                 if(cps->lastPing != cps->lastPong) {
6414                     savedMessage = message; // args for deferred call
6415                     savedState = cps;
6416                     ScheduleDelayedEvent(DeferredBookMove, 10);
6417                     return;
6418                 }
6419                 goto FakeBookMove;
6420         }
6421
6422         return;
6423     }
6424
6425     /* Set special modes for chess engines.  Later something general
6426      *  could be added here; for now there is just one kludge feature,
6427      *  needed because Crafty 15.10 and earlier don't ignore SIGINT
6428      *  when "xboard" is given as an interactive command.
6429      */
6430     if (strncmp(message, "kibitz Hello from Crafty", 24) == 0) {
6431         cps->useSigint = FALSE;
6432         cps->useSigterm = FALSE;
6433     }
6434     if (strncmp(message, "feature ", 8) == 0) { // [HGM] moved forward to pre-empt non-compliant commands
6435       ParseFeatures(message+8, cps);
6436       return; // [HGM] This return was missing, causing option features to be recognized as non-compliant commands!
6437     }
6438
6439     /* [HGM] Allow engine to set up a position. Don't ask me why one would
6440      * want this, I was asked to put it in, and obliged.
6441      */
6442     if (!strncmp(message, "setboard ", 9)) {
6443         Board initial_position; int i;
6444
6445         GameEnds(GameUnfinished, "Engine aborts game", GE_XBOARD);
6446
6447         if (!ParseFEN(initial_position, &blackPlaysFirst, message + 9)) {
6448             DisplayError(_("Bad FEN received from engine"), 0);
6449             return ;
6450         } else {
6451            Reset(TRUE, FALSE);
6452            CopyBoard(boards[0], initial_position);
6453            initialRulePlies = FENrulePlies;
6454            epStatus[0] = FENepStatus;
6455            for( i=0; i<nrCastlingRights; i++ )
6456                 castlingRights[0][i] = FENcastlingRights[i];
6457            if(blackPlaysFirst) gameMode = MachinePlaysWhite;
6458            else gameMode = MachinePlaysBlack;
6459            DrawPosition(FALSE, boards[currentMove]);
6460         }
6461         return;
6462     }
6463
6464     /*
6465      * Look for communication commands
6466      */
6467     if (!strncmp(message, "telluser ", 9)) {
6468         DisplayNote(message + 9);
6469         return;
6470     }
6471     if (!strncmp(message, "tellusererror ", 14)) {
6472         DisplayError(message + 14, 0);
6473         return;
6474     }
6475     if (!strncmp(message, "tellopponent ", 13)) {
6476       if (appData.icsActive) {
6477         if (loggedOn) {
6478           snprintf(buf1, sizeof(buf1), "%ssay %s\n", ics_prefix, message + 13);
6479           SendToICS(buf1);
6480         }
6481       } else {
6482         DisplayNote(message + 13);
6483       }
6484       return;
6485     }
6486     if (!strncmp(message, "tellothers ", 11)) {
6487       if (appData.icsActive) {
6488         if (loggedOn) {
6489           snprintf(buf1, sizeof(buf1), "%swhisper %s\n", ics_prefix, message + 11);
6490           SendToICS(buf1);
6491         }
6492       }
6493       return;
6494     }
6495     if (!strncmp(message, "tellall ", 8)) {
6496       if (appData.icsActive) {
6497         if (loggedOn) {
6498           snprintf(buf1, sizeof(buf1), "%skibitz %s\n", ics_prefix, message + 8);
6499           SendToICS(buf1);
6500         }
6501       } else {
6502         DisplayNote(message + 8);
6503       }
6504       return;
6505     }
6506     if (strncmp(message, "warning", 7) == 0) {
6507         /* Undocumented feature, use tellusererror in new code */
6508         DisplayError(message, 0);
6509         return;
6510     }
6511     if (sscanf(message, "askuser %s %[^\n]", buf1, buf2) == 2) {
6512         strcpy(realname, cps->tidy);
6513         strcat(realname, " query");
6514         AskQuestion(realname, buf2, buf1, cps->pr);
6515         return;
6516     }
6517     /* Commands from the engine directly to ICS.  We don't allow these to be
6518      *  sent until we are logged on. Crafty kibitzes have been known to
6519      *  interfere with the login process.
6520      */
6521     if (loggedOn) {
6522         if (!strncmp(message, "tellics ", 8)) {
6523             SendToICS(message + 8);
6524             SendToICS("\n");
6525             return;
6526         }
6527         if (!strncmp(message, "tellicsnoalias ", 15)) {
6528             SendToICS(ics_prefix);
6529             SendToICS(message + 15);
6530             SendToICS("\n");
6531             return;
6532         }
6533         /* The following are for backward compatibility only */
6534         if (!strncmp(message,"whisper",7) || !strncmp(message,"kibitz",6) ||
6535             !strncmp(message,"draw",4) || !strncmp(message,"tell",3)) {
6536             SendToICS(ics_prefix);
6537             SendToICS(message);
6538             SendToICS("\n");
6539             return;
6540         }
6541     }
6542     if (sscanf(message, "pong %d", &cps->lastPong) == 1) {
6543         return;
6544     }
6545     /*
6546      * If the move is illegal, cancel it and redraw the board.
6547      * Also deal with other error cases.  Matching is rather loose
6548      * here to accommodate engines written before the spec.
6549      */
6550     if (strncmp(message + 1, "llegal move", 11) == 0 ||
6551         strncmp(message, "Error", 5) == 0) {
6552         if (StrStr(message, "name") ||
6553             StrStr(message, "rating") || StrStr(message, "?") ||
6554             StrStr(message, "result") || StrStr(message, "board") ||
6555             StrStr(message, "bk") || StrStr(message, "computer") ||
6556             StrStr(message, "variant") || StrStr(message, "hint") ||
6557             StrStr(message, "random") || StrStr(message, "depth") ||
6558             StrStr(message, "accepted")) {
6559             return;
6560         }
6561         if (StrStr(message, "protover")) {
6562           /* Program is responding to input, so it's apparently done
6563              initializing, and this error message indicates it is
6564              protocol version 1.  So we don't need to wait any longer
6565              for it to initialize and send feature commands. */
6566           FeatureDone(cps, 1);
6567           cps->protocolVersion = 1;
6568           return;
6569         }
6570         cps->maybeThinking = FALSE;
6571
6572         if (StrStr(message, "draw")) {
6573             /* Program doesn't have "draw" command */
6574             cps->sendDrawOffers = 0;
6575             return;
6576         }
6577         if (cps->sendTime != 1 &&
6578             (StrStr(message, "time") || StrStr(message, "otim"))) {
6579           /* Program apparently doesn't have "time" or "otim" command */
6580           cps->sendTime = 0;
6581           return;
6582         }
6583         if (StrStr(message, "analyze")) {
6584             cps->analysisSupport = FALSE;
6585             cps->analyzing = FALSE;
6586             Reset(FALSE, TRUE);
6587             sprintf(buf2, _("%s does not support analysis"), cps->tidy);
6588             DisplayError(buf2, 0);
6589             return;
6590         }
6591         if (StrStr(message, "(no matching move)st")) {
6592           /* Special kludge for GNU Chess 4 only */
6593           cps->stKludge = TRUE;
6594           SendTimeControl(cps, movesPerSession, timeControl,
6595                           timeIncrement, appData.searchDepth,
6596                           searchTime);
6597           return;
6598         }
6599         if (StrStr(message, "(no matching move)sd")) {
6600           /* Special kludge for GNU Chess 4 only */
6601           cps->sdKludge = TRUE;
6602           SendTimeControl(cps, movesPerSession, timeControl,
6603                           timeIncrement, appData.searchDepth,
6604                           searchTime);
6605           return;
6606         }
6607         if (!StrStr(message, "llegal")) {
6608             return;
6609         }
6610         if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
6611             gameMode == IcsIdle) return;
6612         if (forwardMostMove <= backwardMostMove) return;
6613         if (pausing) PauseEvent();
6614       if(appData.forceIllegal) {
6615             // [HGM] illegal: machine refused move; force position after move into it
6616           SendToProgram("force\n", cps);
6617           if(!cps->useSetboard) { // hideous kludge on kludge, because SendBoard sucks.
6618                 // we have a real problem now, as SendBoard will use the a2a3 kludge
6619                 // when black is to move, while there might be nothing on a2 or black
6620                 // might already have the move. So send the board as if white has the move.
6621                 // But first we must change the stm of the engine, as it refused the last move
6622                 SendBoard(cps, 0); // always kludgeless, as white is to move on boards[0]
6623                 if(WhiteOnMove(forwardMostMove)) {
6624                     SendToProgram("a7a6\n", cps); // for the engine black still had the move
6625                     SendBoard(cps, forwardMostMove); // kludgeless board
6626                 } else {
6627                     SendToProgram("a2a3\n", cps); // for the engine white still had the move
6628                     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
6629                     SendBoard(cps, forwardMostMove+1); // kludgeless board
6630                 }
6631           } else SendBoard(cps, forwardMostMove); // FEN case, also sets stm properly
6632             if(gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
6633                  gameMode == TwoMachinesPlay)
6634               SendToProgram("go\n", cps);
6635             return;
6636       } else
6637         if (gameMode == PlayFromGameFile) {
6638             /* Stop reading this game file */
6639             gameMode = EditGame;
6640             ModeHighlight();
6641         }
6642         currentMove = --forwardMostMove;
6643         DisplayMove(currentMove-1); /* before DisplayMoveError */
6644         SwitchClocks();
6645         DisplayBothClocks();
6646         sprintf(buf1, _("Illegal move \"%s\" (rejected by %s chess program)"),
6647                 parseList[currentMove], cps->which);
6648         DisplayMoveError(buf1);
6649         DrawPosition(FALSE, boards[currentMove]);
6650
6651         /* [HGM] illegal-move claim should forfeit game when Xboard */
6652         /* only passes fully legal moves                            */
6653         if( appData.testLegality && gameMode == TwoMachinesPlay ) {
6654             GameEnds( cps->twoMachinesColor[0] == 'w' ? BlackWins : WhiteWins,
6655                                 "False illegal-move claim", GE_XBOARD );
6656         }
6657         return;
6658     }
6659     if (strncmp(message, "time", 4) == 0 && StrStr(message, "Illegal")) {
6660         /* Program has a broken "time" command that
6661            outputs a string not ending in newline.
6662            Don't use it. */
6663         cps->sendTime = 0;
6664     }
6665
6666     /*
6667      * If chess program startup fails, exit with an error message.
6668      * Attempts to recover here are futile.
6669      */
6670     if ((StrStr(message, "unknown host") != NULL)
6671         || (StrStr(message, "No remote directory") != NULL)
6672         || (StrStr(message, "not found") != NULL)
6673         || (StrStr(message, "No such file") != NULL)
6674         || (StrStr(message, "can't alloc") != NULL)
6675         || (StrStr(message, "Permission denied") != NULL)) {
6676
6677         cps->maybeThinking = FALSE;
6678         snprintf(buf1, sizeof(buf1), _("Failed to start %s chess program %s on %s: %s\n"),
6679                 cps->which, cps->program, cps->host, message);
6680         RemoveInputSource(cps->isr);
6681         DisplayFatalError(buf1, 0, 1);
6682         return;
6683     }
6684
6685     /*
6686      * Look for hint output
6687      */
6688     if (sscanf(message, "Hint: %s", buf1) == 1) {
6689         if (cps == &first && hintRequested) {
6690             hintRequested = FALSE;
6691             if (ParseOneMove(buf1, forwardMostMove, &moveType,
6692                                  &fromX, &fromY, &toX, &toY, &promoChar)) {
6693                 (void) CoordsToAlgebraic(boards[forwardMostMove],
6694                                     PosFlags(forwardMostMove), EP_UNKNOWN,
6695                                     fromY, fromX, toY, toX, promoChar, buf1);
6696                 snprintf(buf2, sizeof(buf2), _("Hint: %s"), buf1);
6697                 DisplayInformation(buf2);
6698             } else {
6699                 /* Hint move could not be parsed!? */
6700               snprintf(buf2, sizeof(buf2),
6701                         _("Illegal hint move \"%s\"\nfrom %s chess program"),
6702                         buf1, cps->which);
6703                 DisplayError(buf2, 0);
6704             }
6705         } else {
6706             strcpy(lastHint, buf1);
6707         }
6708         return;
6709     }
6710
6711     /*
6712      * Ignore other messages if game is not in progress
6713      */
6714     if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
6715         gameMode == IcsIdle || cps->lastPing != cps->lastPong) return;
6716
6717     /*
6718      * look for win, lose, draw, or draw offer
6719      */
6720     if (strncmp(message, "1-0", 3) == 0) {
6721         char *p, *q, *r = "";
6722         p = strchr(message, '{');
6723         if (p) {
6724             q = strchr(p, '}');
6725             if (q) {
6726                 *q = NULLCHAR;
6727                 r = p + 1;
6728             }
6729         }
6730         GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first)); /* [HGM] pass claimer indication for claim test */
6731         return;
6732     } else if (strncmp(message, "0-1", 3) == 0) {
6733         char *p, *q, *r = "";
6734         p = strchr(message, '{');
6735         if (p) {
6736             q = strchr(p, '}');
6737             if (q) {
6738                 *q = NULLCHAR;
6739                 r = p + 1;
6740             }
6741         }
6742         /* Kludge for Arasan 4.1 bug */
6743         if (strcmp(r, "Black resigns") == 0) {
6744             GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first));
6745             return;
6746         }
6747         GameEnds(BlackWins, r, GE_ENGINE1 + (cps != &first));
6748         return;
6749     } else if (strncmp(message, "1/2", 3) == 0) {
6750         char *p, *q, *r = "";
6751         p = strchr(message, '{');
6752         if (p) {
6753             q = strchr(p, '}');
6754             if (q) {
6755                 *q = NULLCHAR;
6756                 r = p + 1;
6757             }
6758         }
6759
6760         GameEnds(GameIsDrawn, r, GE_ENGINE1 + (cps != &first));
6761         return;
6762
6763     } else if (strncmp(message, "White resign", 12) == 0) {
6764         GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
6765         return;
6766     } else if (strncmp(message, "Black resign", 12) == 0) {
6767         GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
6768         return;
6769     } else if (strncmp(message, "White matches", 13) == 0 ||
6770                strncmp(message, "Black matches", 13) == 0   ) {
6771         /* [HGM] ignore GNUShogi noises */
6772         return;
6773     } else if (strncmp(message, "White", 5) == 0 &&
6774                message[5] != '(' &&
6775                StrStr(message, "Black") == NULL) {
6776         GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
6777         return;
6778     } else if (strncmp(message, "Black", 5) == 0 &&
6779                message[5] != '(') {
6780         GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
6781         return;
6782     } else if (strcmp(message, "resign") == 0 ||
6783                strcmp(message, "computer resigns") == 0) {
6784         switch (gameMode) {
6785           case MachinePlaysBlack:
6786           case IcsPlayingBlack:
6787             GameEnds(WhiteWins, "Black resigns", GE_ENGINE);
6788             break;
6789           case MachinePlaysWhite:
6790           case IcsPlayingWhite:
6791             GameEnds(BlackWins, "White resigns", GE_ENGINE);
6792             break;
6793           case TwoMachinesPlay:
6794             if (cps->twoMachinesColor[0] == 'w')
6795               GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
6796             else
6797               GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
6798             break;
6799           default:
6800             /* can't happen */
6801             break;
6802         }
6803         return;
6804     } else if (strncmp(message, "opponent mates", 14) == 0) {
6805         switch (gameMode) {
6806           case MachinePlaysBlack:
6807           case IcsPlayingBlack:
6808             GameEnds(WhiteWins, "White mates", GE_ENGINE);
6809             break;
6810           case MachinePlaysWhite:
6811           case IcsPlayingWhite:
6812             GameEnds(BlackWins, "Black mates", GE_ENGINE);
6813             break;
6814           case TwoMachinesPlay:
6815             if (cps->twoMachinesColor[0] == 'w')
6816               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
6817             else
6818               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
6819             break;
6820           default:
6821             /* can't happen */
6822             break;
6823         }
6824         return;
6825     } else if (strncmp(message, "computer mates", 14) == 0) {
6826         switch (gameMode) {
6827           case MachinePlaysBlack:
6828           case IcsPlayingBlack:
6829             GameEnds(BlackWins, "Black mates", GE_ENGINE1);
6830             break;
6831           case MachinePlaysWhite:
6832           case IcsPlayingWhite:
6833             GameEnds(WhiteWins, "White mates", GE_ENGINE);
6834             break;
6835           case TwoMachinesPlay:
6836             if (cps->twoMachinesColor[0] == 'w')
6837               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
6838             else
6839               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
6840             break;
6841           default:
6842             /* can't happen */
6843             break;
6844         }
6845         return;
6846     } else if (strncmp(message, "checkmate", 9) == 0) {
6847         if (WhiteOnMove(forwardMostMove)) {
6848             GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
6849         } else {
6850             GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
6851         }
6852         return;
6853     } else if (strstr(message, "Draw") != NULL ||
6854                strstr(message, "game is a draw") != NULL) {
6855         GameEnds(GameIsDrawn, "Draw", GE_ENGINE1 + (cps != &first));
6856         return;
6857     } else if (strstr(message, "offer") != NULL &&
6858                strstr(message, "draw") != NULL) {
6859 #if ZIPPY
6860         if (appData.zippyPlay && first.initDone) {
6861             /* Relay offer to ICS */
6862             SendToICS(ics_prefix);
6863             SendToICS("draw\n");
6864         }
6865 #endif
6866         cps->offeredDraw = 2; /* valid until this engine moves twice */
6867         if (gameMode == TwoMachinesPlay) {
6868             if (cps->other->offeredDraw) {
6869                 GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
6870             /* [HGM] in two-machine mode we delay relaying draw offer      */
6871             /* until after we also have move, to see if it is really claim */
6872             }
6873         } else if (gameMode == MachinePlaysWhite ||
6874                    gameMode == MachinePlaysBlack) {
6875           if (userOfferedDraw) {
6876             DisplayInformation(_("Machine accepts your draw offer"));
6877             GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
6878           } else {
6879             DisplayInformation(_("Machine offers a draw\nSelect Action / Draw to agree"));
6880           }
6881         }
6882     }
6883
6884
6885     /*
6886      * Look for thinking output
6887      */
6888     if ( appData.showThinking // [HGM] thinking: test all options that cause this output
6889           || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
6890                                 ) {
6891         int plylev, mvleft, mvtot, curscore, time;
6892         char mvname[MOVE_LEN];
6893         u64 nodes; // [DM]
6894         char plyext;
6895         int ignore = FALSE;
6896         int prefixHint = FALSE;
6897         mvname[0] = NULLCHAR;
6898
6899         switch (gameMode) {
6900           case MachinePlaysBlack:
6901           case IcsPlayingBlack:
6902             if (WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
6903             break;
6904           case MachinePlaysWhite:
6905           case IcsPlayingWhite:
6906             if (!WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
6907             break;
6908           case AnalyzeMode:
6909           case AnalyzeFile:
6910             break;
6911           case IcsObserving: /* [DM] icsEngineAnalyze */
6912             if (!appData.icsEngineAnalyze) ignore = TRUE;
6913             break;
6914           case TwoMachinesPlay:
6915             if ((cps->twoMachinesColor[0] == 'w') != WhiteOnMove(forwardMostMove)) {
6916                 ignore = TRUE;
6917             }
6918             break;
6919           default:
6920             ignore = TRUE;
6921             break;
6922         }
6923
6924         if (!ignore) {
6925             buf1[0] = NULLCHAR;
6926             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
6927                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5) {
6928
6929                 if (plyext != ' ' && plyext != '\t') {
6930                     time *= 100;
6931                 }
6932
6933                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
6934                 if( cps->scoreIsAbsolute &&
6935                     ((gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b')) )
6936                 {
6937                     curscore = -curscore;
6938                 }
6939
6940
6941                 programStats.depth = plylev;
6942                 programStats.nodes = nodes;
6943                 programStats.time = time;
6944                 programStats.score = curscore;
6945                 programStats.got_only_move = 0;
6946
6947                 if(cps->nps >= 0) { /* [HGM] nps: use engine nodes or time to decrement clock */
6948                         int ticklen;
6949
6950                         if(cps->nps == 0) ticklen = 10*time;                    // use engine reported time
6951                         else ticklen = (1000. * u64ToDouble(nodes)) / cps->nps; // convert node count to time
6952                         if(WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysWhite ||
6953                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'w'))
6954                              whiteTimeRemaining = timeRemaining[0][forwardMostMove] - ticklen;
6955                         if(!WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysBlack ||
6956                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b'))
6957                              blackTimeRemaining = timeRemaining[1][forwardMostMove] - ticklen;
6958                 }
6959
6960                 /* Buffer overflow protection */
6961                 if (buf1[0] != NULLCHAR) {
6962                     if (strlen(buf1) >= sizeof(programStats.movelist)
6963                         && appData.debugMode) {
6964                         fprintf(debugFP,
6965                                 "PV is too long; using the first %u bytes.\n",
6966                                 (unsigned) sizeof(programStats.movelist) - 1);
6967                     }
6968
6969                     safeStrCpy( programStats.movelist, buf1, sizeof(programStats.movelist) );
6970                 } else {
6971                     sprintf(programStats.movelist, " no PV\n");
6972                 }
6973
6974                 if (programStats.seen_stat) {
6975                     programStats.ok_to_send = 1;
6976                 }
6977
6978                 if (strchr(programStats.movelist, '(') != NULL) {
6979                     programStats.line_is_book = 1;
6980                     programStats.nr_moves = 0;
6981                     programStats.moves_left = 0;
6982                 } else {
6983                     programStats.line_is_book = 0;
6984                 }
6985
6986                 SendProgramStatsToFrontend( cps, &programStats );
6987
6988                 /*
6989                     [AS] Protect the thinkOutput buffer from overflow... this
6990                     is only useful if buf1 hasn't overflowed first!
6991                 */
6992                 sprintf(thinkOutput, "[%d]%c%+.2f %s%s",
6993                         plylev,
6994                         (gameMode == TwoMachinesPlay ?
6995                          ToUpper(cps->twoMachinesColor[0]) : ' '),
6996                         ((double) curscore) / 100.0,
6997                         prefixHint ? lastHint : "",
6998                         prefixHint ? " " : "" );
6999
7000                 if( buf1[0] != NULLCHAR ) {
7001                     unsigned max_len = sizeof(thinkOutput) - strlen(thinkOutput) - 1;
7002
7003                     if( strlen(buf1) > max_len ) {
7004                         if( appData.debugMode) {
7005                             fprintf(debugFP,"PV is too long for thinkOutput, truncating.\n");
7006                         }
7007                         buf1[max_len+1] = '\0';
7008                     }
7009
7010                     strcat( thinkOutput, buf1 );
7011                 }
7012
7013                 if (currentMove == forwardMostMove || gameMode == AnalyzeMode
7014                         || gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
7015                     DisplayMove(currentMove - 1);
7016                 }
7017                 return;
7018
7019             } else if ((p=StrStr(message, "(only move)")) != NULL) {
7020                 /* crafty (9.25+) says "(only move) <move>"
7021                  * if there is only 1 legal move
7022                  */
7023                 sscanf(p, "(only move) %s", buf1);
7024                 sprintf(thinkOutput, "%s (only move)", buf1);
7025                 sprintf(programStats.movelist, "%s (only move)", buf1);
7026                 programStats.depth = 1;
7027                 programStats.nr_moves = 1;
7028                 programStats.moves_left = 1;
7029                 programStats.nodes = 1;
7030                 programStats.time = 1;
7031                 programStats.got_only_move = 1;
7032
7033                 /* Not really, but we also use this member to
7034                    mean "line isn't going to change" (Crafty
7035                    isn't searching, so stats won't change) */
7036                 programStats.line_is_book = 1;
7037
7038                 SendProgramStatsToFrontend( cps, &programStats );
7039
7040                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
7041                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
7042                     DisplayMove(currentMove - 1);
7043                 }
7044                 return;
7045             } else if (sscanf(message,"stat01: %d " u64Display " %d %d %d %s",
7046                               &time, &nodes, &plylev, &mvleft,
7047                               &mvtot, mvname) >= 5) {
7048                 /* The stat01: line is from Crafty (9.29+) in response
7049                    to the "." command */
7050                 programStats.seen_stat = 1;
7051                 cps->maybeThinking = TRUE;
7052
7053                 if (programStats.got_only_move || !appData.periodicUpdates)
7054                   return;
7055
7056                 programStats.depth = plylev;
7057                 programStats.time = time;
7058                 programStats.nodes = nodes;
7059                 programStats.moves_left = mvleft;
7060                 programStats.nr_moves = mvtot;
7061                 strcpy(programStats.move_name, mvname);
7062                 programStats.ok_to_send = 1;
7063                 programStats.movelist[0] = '\0';
7064
7065                 SendProgramStatsToFrontend( cps, &programStats );
7066
7067                 return;
7068
7069             } else if (strncmp(message,"++",2) == 0) {
7070                 /* Crafty 9.29+ outputs this */
7071                 programStats.got_fail = 2;
7072                 return;
7073
7074             } else if (strncmp(message,"--",2) == 0) {
7075                 /* Crafty 9.29+ outputs this */
7076                 programStats.got_fail = 1;
7077                 return;
7078
7079             } else if (thinkOutput[0] != NULLCHAR &&
7080                        strncmp(message, "    ", 4) == 0) {
7081                 unsigned message_len;
7082
7083                 p = message;
7084                 while (*p && *p == ' ') p++;
7085
7086                 message_len = strlen( p );
7087
7088                 /* [AS] Avoid buffer overflow */
7089                 if( sizeof(thinkOutput) - strlen(thinkOutput) - 1 > message_len ) {
7090                     strcat(thinkOutput, " ");
7091                     strcat(thinkOutput, p);
7092                 }
7093
7094                 if( sizeof(programStats.movelist) - strlen(programStats.movelist) - 1 > message_len ) {
7095                     strcat(programStats.movelist, " ");
7096                     strcat(programStats.movelist, p);
7097                 }
7098
7099                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
7100                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
7101                     DisplayMove(currentMove - 1);
7102                 }
7103                 return;
7104             }
7105         }
7106         else {
7107             buf1[0] = NULLCHAR;
7108
7109             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
7110                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5)
7111             {
7112                 ChessProgramStats cpstats;
7113
7114                 if (plyext != ' ' && plyext != '\t') {
7115                     time *= 100;
7116                 }
7117
7118                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
7119                 if( cps->scoreIsAbsolute && ((gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b')) ) {
7120                     curscore = -curscore;
7121                 }
7122
7123                 cpstats.depth = plylev;
7124                 cpstats.nodes = nodes;
7125                 cpstats.time = time;
7126                 cpstats.score = curscore;
7127                 cpstats.got_only_move = 0;
7128                 cpstats.movelist[0] = '\0';
7129
7130                 if (buf1[0] != NULLCHAR) {
7131                     safeStrCpy( cpstats.movelist, buf1, sizeof(cpstats.movelist) );
7132                 }
7133
7134                 cpstats.ok_to_send = 0;
7135                 cpstats.line_is_book = 0;
7136                 cpstats.nr_moves = 0;
7137                 cpstats.moves_left = 0;
7138
7139                 SendProgramStatsToFrontend( cps, &cpstats );
7140             }
7141         }
7142     }
7143 }
7144
7145
7146 /* Parse a game score from the character string "game", and
7147    record it as the history of the current game.  The game
7148    score is NOT assumed to start from the standard position.
7149    The display is not updated in any way.
7150    */
7151 void
7152 ParseGameHistory(game)
7153      char *game;
7154 {
7155     ChessMove moveType;
7156     int fromX, fromY, toX, toY, boardIndex;
7157     char promoChar;
7158     char *p, *q;
7159     char buf[MSG_SIZ];
7160
7161     if (appData.debugMode)
7162       fprintf(debugFP, "Parsing game history: %s\n", game);
7163
7164     if (gameInfo.event == NULL) gameInfo.event = StrSave("ICS game");
7165     gameInfo.site = StrSave(appData.icsHost);
7166     gameInfo.date = PGNDate();
7167     gameInfo.round = StrSave("-");
7168
7169     /* Parse out names of players */
7170     while (*game == ' ') game++;
7171     p = buf;
7172     while (*game != ' ') *p++ = *game++;
7173     *p = NULLCHAR;
7174     gameInfo.white = StrSave(buf);
7175     while (*game == ' ') game++;
7176     p = buf;
7177     while (*game != ' ' && *game != '\n') *p++ = *game++;
7178     *p = NULLCHAR;
7179     gameInfo.black = StrSave(buf);
7180
7181     /* Parse moves */
7182     boardIndex = blackPlaysFirst ? 1 : 0;
7183     yynewstr(game);
7184     for (;;) {
7185         yyboardindex = boardIndex;
7186         moveType = (ChessMove) yylex();
7187         switch (moveType) {
7188           case IllegalMove:             /* maybe suicide chess, etc. */
7189   if (appData.debugMode) {
7190     fprintf(debugFP, "Illegal move from ICS: '%s'\n", yy_text);
7191     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
7192     setbuf(debugFP, NULL);
7193   }
7194           case WhitePromotionChancellor:
7195           case BlackPromotionChancellor:
7196           case WhitePromotionArchbishop:
7197           case BlackPromotionArchbishop:
7198           case WhitePromotionQueen:
7199           case BlackPromotionQueen:
7200           case WhitePromotionRook:
7201           case BlackPromotionRook:
7202           case WhitePromotionBishop:
7203           case BlackPromotionBishop:
7204           case WhitePromotionKnight:
7205           case BlackPromotionKnight:
7206           case WhitePromotionKing:
7207           case BlackPromotionKing:
7208           case NormalMove:
7209           case WhiteCapturesEnPassant:
7210           case BlackCapturesEnPassant:
7211           case WhiteKingSideCastle:
7212           case WhiteQueenSideCastle:
7213           case BlackKingSideCastle:
7214           case BlackQueenSideCastle:
7215           case WhiteKingSideCastleWild:
7216           case WhiteQueenSideCastleWild:
7217           case BlackKingSideCastleWild:
7218           case BlackQueenSideCastleWild:
7219           /* PUSH Fabien */
7220           case WhiteHSideCastleFR:
7221           case WhiteASideCastleFR:
7222           case BlackHSideCastleFR:
7223           case BlackASideCastleFR:
7224           /* POP Fabien */
7225             fromX = currentMoveString[0] - AAA;
7226             fromY = currentMoveString[1] - ONE;
7227             toX = currentMoveString[2] - AAA;
7228             toY = currentMoveString[3] - ONE;
7229             promoChar = currentMoveString[4];
7230             break;
7231           case WhiteDrop:
7232           case BlackDrop:
7233             fromX = moveType == WhiteDrop ?
7234               (int) CharToPiece(ToUpper(currentMoveString[0])) :
7235             (int) CharToPiece(ToLower(currentMoveString[0]));
7236             fromY = DROP_RANK;
7237             toX = currentMoveString[2] - AAA;
7238             toY = currentMoveString[3] - ONE;
7239             promoChar = NULLCHAR;
7240             break;
7241           case AmbiguousMove:
7242             /* bug? */
7243             sprintf(buf, _("Ambiguous move in ICS output: \"%s\""), yy_text);
7244   if (appData.debugMode) {
7245     fprintf(debugFP, "Ambiguous move from ICS: '%s'\n", yy_text);
7246     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
7247     setbuf(debugFP, NULL);
7248   }
7249             DisplayError(buf, 0);
7250             return;
7251           case ImpossibleMove:
7252             /* bug? */
7253             sprintf(buf, _("Illegal move in ICS output: \"%s\""), yy_text);
7254   if (appData.debugMode) {
7255     fprintf(debugFP, "Impossible move from ICS: '%s'\n", yy_text);
7256     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
7257     setbuf(debugFP, NULL);
7258   }
7259             DisplayError(buf, 0);
7260             return;
7261           case (ChessMove) 0:   /* end of file */
7262             if (boardIndex < backwardMostMove) {
7263                 /* Oops, gap.  How did that happen? */
7264                 DisplayError(_("Gap in move list"), 0);
7265                 return;
7266             }
7267             backwardMostMove =  blackPlaysFirst ? 1 : 0;
7268             if (boardIndex > forwardMostMove) {
7269                 forwardMostMove = boardIndex;
7270             }
7271             return;
7272           case ElapsedTime:
7273             if (boardIndex > (blackPlaysFirst ? 1 : 0)) {
7274                 strcat(parseList[boardIndex-1], " ");
7275                 strcat(parseList[boardIndex-1], yy_text);
7276             }
7277             continue;
7278           case Comment:
7279           case PGNTag:
7280           case NAG:
7281           default:
7282             /* ignore */
7283             continue;
7284           case WhiteWins:
7285           case BlackWins:
7286           case GameIsDrawn:
7287           case GameUnfinished:
7288             if (gameMode == IcsExamining) {
7289                 if (boardIndex < backwardMostMove) {
7290                     /* Oops, gap.  How did that happen? */
7291                     return;
7292                 }
7293                 backwardMostMove = blackPlaysFirst ? 1 : 0;
7294                 return;
7295             }
7296             gameInfo.result = moveType;
7297             p = strchr(yy_text, '{');
7298             if (p == NULL) p = strchr(yy_text, '(');
7299             if (p == NULL) {
7300                 p = yy_text;
7301                 if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
7302             } else {
7303                 q = strchr(p, *p == '{' ? '}' : ')');
7304                 if (q != NULL) *q = NULLCHAR;
7305                 p++;
7306             }
7307             gameInfo.resultDetails = StrSave(p);
7308             continue;
7309         }
7310         if (boardIndex >= forwardMostMove &&
7311             !(gameMode == IcsObserving && ics_gamenum == -1)) {
7312             backwardMostMove = blackPlaysFirst ? 1 : 0;
7313             return;
7314         }
7315         (void) CoordsToAlgebraic(boards[boardIndex], PosFlags(boardIndex),
7316                                  EP_UNKNOWN, fromY, fromX, toY, toX, promoChar,
7317                                  parseList[boardIndex]);
7318         CopyBoard(boards[boardIndex + 1], boards[boardIndex]);
7319         {int i; for(i=0; i<BOARD_SIZE; i++) castlingRights[boardIndex+1][i] = castlingRights[boardIndex][i];}
7320         /* currentMoveString is set as a side-effect of yylex */
7321         strcpy(moveList[boardIndex], currentMoveString);
7322         strcat(moveList[boardIndex], "\n");
7323         boardIndex++;
7324         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[boardIndex],
7325                                         castlingRights[boardIndex], &epStatus[boardIndex]);
7326         switch (MateTest(boards[boardIndex], PosFlags(boardIndex),
7327                                  EP_UNKNOWN, castlingRights[boardIndex]) ) {
7328           case MT_NONE:
7329           case MT_STALEMATE:
7330           default:
7331             break;
7332           case MT_CHECK:
7333             if(gameInfo.variant != VariantShogi)
7334                 strcat(parseList[boardIndex - 1], "+");
7335             break;
7336           case MT_CHECKMATE:
7337           case MT_STAINMATE:
7338             strcat(parseList[boardIndex - 1], "#");
7339             break;
7340         }
7341     }
7342 }
7343
7344
7345 /* Apply a move to the given board  */
7346 void
7347 ApplyMove(fromX, fromY, toX, toY, promoChar, board, castling, ep)
7348      int fromX, fromY, toX, toY;
7349      int promoChar;
7350      Board board;
7351      char *castling;
7352      char *ep;
7353 {
7354   ChessSquare captured = board[toY][toX], piece, king; int p, oldEP = EP_NONE, berolina = 0;
7355
7356     /* [HGM] compute & store e.p. status and castling rights for new position */
7357     /* we can always do that 'in place', now pointers to these rights are passed to ApplyMove */
7358     { int i;
7359
7360       if(gameInfo.variant == VariantBerolina) berolina = EP_BEROLIN_A;
7361       oldEP = *ep;
7362       *ep = EP_NONE;
7363
7364       if( board[toY][toX] != EmptySquare )
7365            *ep = EP_CAPTURE;
7366
7367       if( board[fromY][fromX] == WhitePawn ) {
7368            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
7369                *ep = EP_PAWN_MOVE;
7370            if( toY-fromY==2) {
7371                if(toX>BOARD_LEFT   && board[toY][toX-1] == BlackPawn &&
7372                         gameInfo.variant != VariantBerolina || toX < fromX)
7373                       *ep = toX | berolina;
7374                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == BlackPawn &&
7375                         gameInfo.variant != VariantBerolina || toX > fromX)
7376                       *ep = toX;
7377            }
7378       } else
7379       if( board[fromY][fromX] == BlackPawn ) {
7380            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
7381                *ep = EP_PAWN_MOVE;
7382            if( toY-fromY== -2) {
7383                if(toX>BOARD_LEFT   && board[toY][toX-1] == WhitePawn &&
7384                         gameInfo.variant != VariantBerolina || toX < fromX)
7385                       *ep = toX | berolina;
7386                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == WhitePawn &&
7387                         gameInfo.variant != VariantBerolina || toX > fromX)
7388                       *ep = toX;
7389            }
7390        }
7391
7392        for(i=0; i<nrCastlingRights; i++) {
7393            if(castling[i] == fromX && castlingRank[i] == fromY ||
7394               castling[i] == toX   && castlingRank[i] == toY
7395              ) castling[i] = -1; // revoke for moved or captured piece
7396        }
7397
7398     }
7399
7400   /* [HGM] In Shatranj and Courier all promotions are to Ferz */
7401   if((gameInfo.variant==VariantShatranj || gameInfo.variant==VariantCourier)
7402        && promoChar != 0) promoChar = PieceToChar(WhiteFerz);
7403
7404   if (fromX == toX && fromY == toY) return;
7405
7406   if (fromY == DROP_RANK) {
7407         /* must be first */
7408         piece = board[toY][toX] = (ChessSquare) fromX;
7409   } else {
7410      piece = board[fromY][fromX]; /* [HGM] remember, for Shogi promotion */
7411      king = piece < (int) BlackPawn ? WhiteKing : BlackKing; /* [HGM] Knightmate simplify testing for castling */
7412      if(gameInfo.variant == VariantKnightmate)
7413          king += (int) WhiteUnicorn - (int) WhiteKing;
7414
7415     /* Code added by Tord: */
7416     /* FRC castling assumed when king captures friendly rook. */
7417     if (board[fromY][fromX] == WhiteKing &&
7418              board[toY][toX] == WhiteRook) {
7419       board[fromY][fromX] = EmptySquare;
7420       board[toY][toX] = EmptySquare;
7421       if(toX > fromX) {
7422         board[0][BOARD_RGHT-2] = WhiteKing; board[0][BOARD_RGHT-3] = WhiteRook;
7423       } else {
7424         board[0][BOARD_LEFT+2] = WhiteKing; board[0][BOARD_LEFT+3] = WhiteRook;
7425       }
7426     } else if (board[fromY][fromX] == BlackKing &&
7427                board[toY][toX] == BlackRook) {
7428       board[fromY][fromX] = EmptySquare;
7429       board[toY][toX] = EmptySquare;
7430       if(toX > fromX) {
7431         board[BOARD_HEIGHT-1][BOARD_RGHT-2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_RGHT-3] = BlackRook;
7432       } else {
7433         board[BOARD_HEIGHT-1][BOARD_LEFT+2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_LEFT+3] = BlackRook;
7434       }
7435     /* End of code added by Tord */
7436
7437     } else if (board[fromY][fromX] == king
7438         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
7439         && toY == fromY && toX > fromX+1) {
7440         board[fromY][fromX] = EmptySquare;
7441         board[toY][toX] = king;
7442         board[toY][toX-1] = board[fromY][BOARD_RGHT-1];
7443         board[fromY][BOARD_RGHT-1] = EmptySquare;
7444     } else if (board[fromY][fromX] == king
7445         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
7446                && toY == fromY && toX < fromX-1) {
7447         board[fromY][fromX] = EmptySquare;
7448         board[toY][toX] = king;
7449         board[toY][toX+1] = board[fromY][BOARD_LEFT];
7450         board[fromY][BOARD_LEFT] = EmptySquare;
7451     } else if (board[fromY][fromX] == WhitePawn
7452                && toY == BOARD_HEIGHT-1
7453                && gameInfo.variant != VariantXiangqi
7454                ) {
7455         /* white pawn promotion */
7456         board[toY][toX] = CharToPiece(ToUpper(promoChar));
7457         if (board[toY][toX] == EmptySquare) {
7458             board[toY][toX] = WhiteQueen;
7459         }
7460         if(gameInfo.variant==VariantBughouse ||
7461            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
7462             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
7463         board[fromY][fromX] = EmptySquare;
7464     } else if ((fromY == BOARD_HEIGHT-4)
7465                && (toX != fromX)
7466                && gameInfo.variant != VariantXiangqi
7467                && gameInfo.variant != VariantBerolina
7468                && (board[fromY][fromX] == WhitePawn)
7469                && (board[toY][toX] == EmptySquare)) {
7470         board[fromY][fromX] = EmptySquare;
7471         board[toY][toX] = WhitePawn;
7472         captured = board[toY - 1][toX];
7473         board[toY - 1][toX] = EmptySquare;
7474     } else if ((fromY == BOARD_HEIGHT-4)
7475                && (toX == fromX)
7476                && gameInfo.variant == VariantBerolina
7477                && (board[fromY][fromX] == WhitePawn)
7478                && (board[toY][toX] == EmptySquare)) {
7479         board[fromY][fromX] = EmptySquare;
7480         board[toY][toX] = WhitePawn;
7481         if(oldEP & EP_BEROLIN_A) {
7482                 captured = board[fromY][fromX-1];
7483                 board[fromY][fromX-1] = EmptySquare;
7484         }else{  captured = board[fromY][fromX+1];
7485                 board[fromY][fromX+1] = EmptySquare;
7486         }
7487     } else if (board[fromY][fromX] == king
7488         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
7489                && toY == fromY && toX > fromX+1) {
7490         board[fromY][fromX] = EmptySquare;
7491         board[toY][toX] = king;
7492         board[toY][toX-1] = board[fromY][BOARD_RGHT-1];
7493         board[fromY][BOARD_RGHT-1] = EmptySquare;
7494     } else if (board[fromY][fromX] == king
7495         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
7496                && toY == fromY && toX < fromX-1) {
7497         board[fromY][fromX] = EmptySquare;
7498         board[toY][toX] = king;
7499         board[toY][toX+1] = board[fromY][BOARD_LEFT];
7500         board[fromY][BOARD_LEFT] = EmptySquare;
7501     } else if (fromY == 7 && fromX == 3
7502                && board[fromY][fromX] == BlackKing
7503                && toY == 7 && toX == 5) {
7504         board[fromY][fromX] = EmptySquare;
7505         board[toY][toX] = BlackKing;
7506         board[fromY][7] = EmptySquare;
7507         board[toY][4] = BlackRook;
7508     } else if (fromY == 7 && fromX == 3
7509                && board[fromY][fromX] == BlackKing
7510                && toY == 7 && toX == 1) {
7511         board[fromY][fromX] = EmptySquare;
7512         board[toY][toX] = BlackKing;
7513         board[fromY][0] = EmptySquare;
7514         board[toY][2] = BlackRook;
7515     } else if (board[fromY][fromX] == BlackPawn
7516                && toY == 0
7517                && gameInfo.variant != VariantXiangqi
7518                ) {
7519         /* black pawn promotion */
7520         board[0][toX] = CharToPiece(ToLower(promoChar));
7521         if (board[0][toX] == EmptySquare) {
7522             board[0][toX] = BlackQueen;
7523         }
7524         if(gameInfo.variant==VariantBughouse ||
7525            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
7526             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
7527         board[fromY][fromX] = EmptySquare;
7528     } else if ((fromY == 3)
7529                && (toX != fromX)
7530                && gameInfo.variant != VariantXiangqi
7531                && gameInfo.variant != VariantBerolina
7532                && (board[fromY][fromX] == BlackPawn)
7533                && (board[toY][toX] == EmptySquare)) {
7534         board[fromY][fromX] = EmptySquare;
7535         board[toY][toX] = BlackPawn;
7536         captured = board[toY + 1][toX];
7537         board[toY + 1][toX] = EmptySquare;
7538     } else if ((fromY == 3)
7539                && (toX == fromX)
7540                && gameInfo.variant == VariantBerolina
7541                && (board[fromY][fromX] == BlackPawn)
7542                && (board[toY][toX] == EmptySquare)) {
7543         board[fromY][fromX] = EmptySquare;
7544         board[toY][toX] = BlackPawn;
7545         if(oldEP & EP_BEROLIN_A) {
7546                 captured = board[fromY][fromX-1];
7547                 board[fromY][fromX-1] = EmptySquare;
7548         }else{  captured = board[fromY][fromX+1];
7549                 board[fromY][fromX+1] = EmptySquare;
7550         }
7551     } else {
7552         board[toY][toX] = board[fromY][fromX];
7553         board[fromY][fromX] = EmptySquare;
7554     }
7555
7556     /* [HGM] now we promote for Shogi, if needed */
7557     if(gameInfo.variant == VariantShogi && promoChar == 'q')
7558         board[toY][toX] = (ChessSquare) (PROMOTED piece);
7559   }
7560
7561     if (gameInfo.holdingsWidth != 0) {
7562
7563       /* !!A lot more code needs to be written to support holdings  */
7564       /* [HGM] OK, so I have written it. Holdings are stored in the */
7565       /* penultimate board files, so they are automaticlly stored   */
7566       /* in the game history.                                       */
7567       if (fromY == DROP_RANK) {
7568         /* Delete from holdings, by decreasing count */
7569         /* and erasing image if necessary            */
7570         p = (int) fromX;
7571         if(p < (int) BlackPawn) { /* white drop */
7572              p -= (int)WhitePawn;
7573                  p = PieceToNumber((ChessSquare)p);
7574              if(p >= gameInfo.holdingsSize) p = 0;
7575              if(--board[p][BOARD_WIDTH-2] <= 0)
7576                   board[p][BOARD_WIDTH-1] = EmptySquare;
7577              if((int)board[p][BOARD_WIDTH-2] < 0)
7578                         board[p][BOARD_WIDTH-2] = 0;
7579         } else {                  /* black drop */
7580              p -= (int)BlackPawn;
7581                  p = PieceToNumber((ChessSquare)p);
7582              if(p >= gameInfo.holdingsSize) p = 0;
7583              if(--board[BOARD_HEIGHT-1-p][1] <= 0)
7584                   board[BOARD_HEIGHT-1-p][0] = EmptySquare;
7585              if((int)board[BOARD_HEIGHT-1-p][1] < 0)
7586                         board[BOARD_HEIGHT-1-p][1] = 0;
7587         }
7588       }
7589       if (captured != EmptySquare && gameInfo.holdingsSize > 0
7590           && gameInfo.variant != VariantBughouse        ) {
7591         /* [HGM] holdings: Add to holdings, if holdings exist */
7592         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
7593                 // [HGM] superchess: suppress flipping color of captured pieces by reverse pre-flip
7594                 captured = (int) captured >= (int) BlackPawn ? BLACK_TO_WHITE captured : WHITE_TO_BLACK captured;
7595         }
7596         p = (int) captured;
7597         if (p >= (int) BlackPawn) {
7598           p -= (int)BlackPawn;
7599           if(gameInfo.variant == VariantShogi && DEMOTED p >= 0) {
7600                   /* in Shogi restore piece to its original  first */
7601                   captured = (ChessSquare) (DEMOTED captured);
7602                   p = DEMOTED p;
7603           }
7604           p = PieceToNumber((ChessSquare)p);
7605           if(p >= gameInfo.holdingsSize) { p = 0; captured = BlackPawn; }
7606           board[p][BOARD_WIDTH-2]++;
7607           board[p][BOARD_WIDTH-1] = BLACK_TO_WHITE captured;
7608         } else {
7609           p -= (int)WhitePawn;
7610           if(gameInfo.variant == VariantShogi && DEMOTED p >= 0) {
7611                   captured = (ChessSquare) (DEMOTED captured);
7612                   p = DEMOTED p;
7613           }
7614           p = PieceToNumber((ChessSquare)p);
7615           if(p >= gameInfo.holdingsSize) { p = 0; captured = WhitePawn; }
7616           board[BOARD_HEIGHT-1-p][1]++;
7617           board[BOARD_HEIGHT-1-p][0] = WHITE_TO_BLACK captured;
7618         }
7619       }
7620     } else if (gameInfo.variant == VariantAtomic) {
7621       if (captured != EmptySquare) {
7622         int y, x;
7623         for (y = toY-1; y <= toY+1; y++) {
7624           for (x = toX-1; x <= toX+1; x++) {
7625             if (y >= 0 && y < BOARD_HEIGHT && x >= BOARD_LEFT && x < BOARD_RGHT &&
7626                 board[y][x] != WhitePawn && board[y][x] != BlackPawn) {
7627               board[y][x] = EmptySquare;
7628             }
7629           }
7630         }
7631         board[toY][toX] = EmptySquare;
7632       }
7633     }
7634     if(gameInfo.variant == VariantShogi && promoChar != NULLCHAR && promoChar != '=') {
7635         /* [HGM] Shogi promotions */
7636         board[toY][toX] = (ChessSquare) (PROMOTED piece);
7637     }
7638
7639     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
7640                 && promoChar != NULLCHAR && gameInfo.holdingsSize) {
7641         // [HGM] superchess: take promotion piece out of holdings
7642         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
7643         if((int)piece < (int)BlackPawn) { // determine stm from piece color
7644             if(!--board[k][BOARD_WIDTH-2])
7645                 board[k][BOARD_WIDTH-1] = EmptySquare;
7646         } else {
7647             if(!--board[BOARD_HEIGHT-1-k][1])
7648                 board[BOARD_HEIGHT-1-k][0] = EmptySquare;
7649         }
7650     }
7651
7652 }
7653
7654 /* Updates forwardMostMove */
7655 void
7656 MakeMove(fromX, fromY, toX, toY, promoChar)
7657      int fromX, fromY, toX, toY;
7658      int promoChar;
7659 {
7660 //    forwardMostMove++; // [HGM] bare: moved downstream
7661
7662     if(serverMoves != NULL) { /* [HGM] write moves on file for broadcasting (should be separate routine, really) */
7663         int timeLeft; static int lastLoadFlag=0; int king, piece;
7664         piece = boards[forwardMostMove][fromY][fromX];
7665         king = piece < (int) BlackPawn ? WhiteKing : BlackKing;
7666         if(gameInfo.variant == VariantKnightmate)
7667             king += (int) WhiteUnicorn - (int) WhiteKing;
7668         if(forwardMostMove == 0) {
7669             if(blackPlaysFirst)
7670                 fprintf(serverMoves, "%s;", second.tidy);
7671             fprintf(serverMoves, "%s;", first.tidy);
7672             if(!blackPlaysFirst)
7673                 fprintf(serverMoves, "%s;", second.tidy);
7674         } else fprintf(serverMoves, loadFlag|lastLoadFlag ? ":" : ";");
7675         lastLoadFlag = loadFlag;
7676         // print base move
7677         fprintf(serverMoves, "%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+toY);
7678         // print castling suffix
7679         if( toY == fromY && piece == king ) {
7680             if(toX-fromX > 1)
7681                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_RGHT-1, ONE+fromY, AAA+toX-1,ONE+toY);
7682             if(fromX-toX >1)
7683                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_LEFT, ONE+fromY, AAA+toX+1,ONE+toY);
7684         }
7685         // e.p. suffix
7686         if( (boards[forwardMostMove][fromY][fromX] == WhitePawn ||
7687              boards[forwardMostMove][fromY][fromX] == BlackPawn   ) &&
7688              boards[forwardMostMove][toY][toX] == EmptySquare
7689              && fromX != toX )
7690                 fprintf(serverMoves, ":%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+fromY);
7691         // promotion suffix
7692         if(promoChar != NULLCHAR)
7693                 fprintf(serverMoves, ":%c:%c%c", promoChar, AAA+toX, ONE+toY);
7694         if(!loadFlag) {
7695             fprintf(serverMoves, "/%d/%d",
7696                pvInfoList[forwardMostMove].depth, pvInfoList[forwardMostMove].score);
7697             if(forwardMostMove+1 & 1) timeLeft = whiteTimeRemaining/1000;
7698             else                      timeLeft = blackTimeRemaining/1000;
7699             fprintf(serverMoves, "/%d", timeLeft);
7700         }
7701         fflush(serverMoves);
7702     }
7703
7704     if (forwardMostMove+1 >= MAX_MOVES) {
7705       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
7706                         0, 1);
7707       return;
7708     }
7709     if (commentList[forwardMostMove+1] != NULL) {
7710         free(commentList[forwardMostMove+1]);
7711         commentList[forwardMostMove+1] = NULL;
7712     }
7713     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
7714     {int i; for(i=0; i<BOARD_SIZE; i++) castlingRights[forwardMostMove+1][i] = castlingRights[forwardMostMove][i];}
7715     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[forwardMostMove+1],
7716                                 castlingRights[forwardMostMove+1], &epStatus[forwardMostMove+1]);
7717     forwardMostMove++; // [HGM] bare: moved to after ApplyMove, to make sure clock interrupt finds complete board
7718     SwitchClocks(); // uses forwardMostMove, so must be done after incrementing it !
7719     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
7720     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
7721     gameInfo.result = GameUnfinished;
7722     if (gameInfo.resultDetails != NULL) {
7723         free(gameInfo.resultDetails);
7724         gameInfo.resultDetails = NULL;
7725     }
7726     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar,
7727                               moveList[forwardMostMove - 1]);
7728     (void) CoordsToAlgebraic(boards[forwardMostMove - 1],
7729                              PosFlags(forwardMostMove - 1), EP_UNKNOWN,
7730                              fromY, fromX, toY, toX, promoChar,
7731                              parseList[forwardMostMove - 1]);
7732     switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove),
7733                        epStatus[forwardMostMove], /* [HGM] use true e.p. */
7734                             castlingRights[forwardMostMove]) ) {
7735       case MT_NONE:
7736       case MT_STALEMATE:
7737       default:
7738         break;
7739       case MT_CHECK:
7740         if(gameInfo.variant != VariantShogi)
7741             strcat(parseList[forwardMostMove - 1], "+");
7742         break;
7743       case MT_CHECKMATE:
7744       case MT_STAINMATE:
7745         strcat(parseList[forwardMostMove - 1], "#");
7746         break;
7747     }
7748     if (appData.debugMode) {
7749         fprintf(debugFP, "move: %s, parse: %s (%c)\n", moveList[forwardMostMove-1], parseList[forwardMostMove-1], moveList[forwardMostMove-1][4]);
7750     }
7751
7752 }
7753
7754 /* Updates currentMove if not pausing */
7755 void
7756 ShowMove(fromX, fromY, toX, toY)
7757 {
7758     int instant = (gameMode == PlayFromGameFile) ?
7759         (matchMode || (appData.timeDelay == 0 && !pausing)) : pausing;
7760     if(appData.noGUI) return;
7761     if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
7762         if (!instant) {
7763             if (forwardMostMove == currentMove + 1) {
7764                 AnimateMove(boards[forwardMostMove - 1],
7765                             fromX, fromY, toX, toY);
7766             }
7767             if (appData.highlightLastMove) {
7768                 SetHighlights(fromX, fromY, toX, toY);
7769             }
7770         }
7771         currentMove = forwardMostMove;
7772     }
7773
7774     if (instant) return;
7775
7776     DisplayMove(currentMove - 1);
7777     DrawPosition(FALSE, boards[currentMove]);
7778     DisplayBothClocks();
7779     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
7780 }
7781
7782 void SendEgtPath(ChessProgramState *cps)
7783 {       /* [HGM] EGT: match formats given in feature with those given by user, and send info for each match */
7784         char buf[MSG_SIZ], name[MSG_SIZ], *p;
7785
7786         if((p = cps->egtFormats) == NULL || appData.egtFormats == NULL) return;
7787
7788         while(*p) {
7789             char c, *q = name+1, *r, *s;
7790
7791             name[0] = ','; // extract next format name from feature and copy with prefixed ','
7792             while(*p && *p != ',') *q++ = *p++;
7793             *q++ = ':'; *q = 0;
7794             if( appData.defaultPathEGTB && appData.defaultPathEGTB[0] &&
7795                 strcmp(name, ",nalimov:") == 0 ) {
7796                 // take nalimov path from the menu-changeable option first, if it is defined
7797                 sprintf(buf, "egtpath nalimov %s\n", appData.defaultPathEGTB);
7798                 SendToProgram(buf,cps);     // send egtbpath command for nalimov
7799             } else
7800             if( (s = StrStr(appData.egtFormats, name+1)) == appData.egtFormats ||
7801                 (s = StrStr(appData.egtFormats, name)) != NULL) {
7802                 // format name occurs amongst user-supplied formats, at beginning or immediately after comma
7803                 s = r = StrStr(s, ":") + 1; // beginning of path info
7804                 while(*r && *r != ',') r++; // path info is everything upto next ';' or end of string
7805                 c = *r; *r = 0;             // temporarily null-terminate path info
7806                     *--q = 0;               // strip of trailig ':' from name
7807                     sprintf(buf, "egtpath %s %s\n", name+1, s);
7808                 *r = c;
7809                 SendToProgram(buf,cps);     // send egtbpath command for this format
7810             }
7811             if(*p == ',') p++; // read away comma to position for next format name
7812         }
7813 }
7814
7815 void
7816 InitChessProgram(cps, setup)
7817      ChessProgramState *cps;
7818      int setup; /* [HGM] needed to setup FRC opening position */
7819 {
7820     char buf[MSG_SIZ], b[MSG_SIZ]; int overruled;
7821     if (appData.noChessProgram) return;
7822     hintRequested = FALSE;
7823     bookRequested = FALSE;
7824
7825     /* [HGM] some new WB protocol commands to configure engine are sent now, if engine supports them */
7826     /*       moved to before sending initstring in 4.3.15, so Polyglot can delay UCI 'isready' to recepton of 'new' */
7827     if(cps->memSize) { /* [HGM] memory */
7828         sprintf(buf, "memory %d\n", appData.defaultHashSize + appData.defaultCacheSizeEGTB);
7829         SendToProgram(buf, cps);
7830     }
7831     SendEgtPath(cps); /* [HGM] EGT */
7832     if(cps->maxCores) { /* [HGM] SMP: (protocol specified must be last settings command before new!) */
7833         sprintf(buf, "cores %d\n", appData.smpCores);
7834         SendToProgram(buf, cps);
7835     }
7836
7837     SendToProgram(cps->initString, cps);
7838     if (gameInfo.variant != VariantNormal &&
7839         gameInfo.variant != VariantLoadable
7840         /* [HGM] also send variant if board size non-standard */
7841         || gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0
7842                                             ) {
7843       char *v = VariantName(gameInfo.variant);
7844       if (cps->protocolVersion != 1 && StrStr(cps->variants, v) == NULL) {
7845         /* [HGM] in protocol 1 we have to assume all variants valid */
7846         sprintf(buf, _("Variant %s not supported by %s"), v, cps->tidy);
7847         DisplayFatalError(buf, 0, 1);
7848         return;
7849       }
7850
7851       /* [HGM] make prefix for non-standard board size. Awkward testing... */
7852       overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
7853       if( gameInfo.variant == VariantXiangqi )
7854            overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 10 || gameInfo.holdingsSize != 0;
7855       if( gameInfo.variant == VariantShogi )
7856            overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 9 || gameInfo.holdingsSize != 7;
7857       if( gameInfo.variant == VariantBughouse || gameInfo.variant == VariantCrazyhouse )
7858            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 5;
7859       if( gameInfo.variant == VariantCapablanca || gameInfo.variant == VariantCapaRandom ||
7860                                gameInfo.variant == VariantGothic  || gameInfo.variant == VariantFalcon )
7861            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
7862       if( gameInfo.variant == VariantCourier )
7863            overruled = gameInfo.boardWidth != 12 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
7864       if( gameInfo.variant == VariantSuper )
7865            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
7866       if( gameInfo.variant == VariantGreat )
7867            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
7868
7869       if(overruled) {
7870            sprintf(b, "%dx%d+%d_%s", gameInfo.boardWidth, gameInfo.boardHeight,
7871                                gameInfo.holdingsSize, VariantName(gameInfo.variant)); // cook up sized variant name
7872            /* [HGM] varsize: try first if this defiant size variant is specifically known */
7873            if(StrStr(cps->variants, b) == NULL) {
7874                // specific sized variant not known, check if general sizing allowed
7875                if (cps->protocolVersion != 1) { // for protocol 1 we cannot check and hope for the best
7876                    if(StrStr(cps->variants, "boardsize") == NULL) {
7877                        sprintf(buf, "Board size %dx%d+%d not supported by %s",
7878                             gameInfo.boardWidth, gameInfo.boardHeight, gameInfo.holdingsSize, cps->tidy);
7879                        DisplayFatalError(buf, 0, 1);
7880                        return;
7881                    }
7882                    /* [HGM] here we really should compare with the maximum supported board size */
7883                }
7884            }
7885       } else sprintf(b, "%s", VariantName(gameInfo.variant));
7886       sprintf(buf, "variant %s\n", b);
7887       SendToProgram(buf, cps);
7888     }
7889     currentlyInitializedVariant = gameInfo.variant;
7890
7891     /* [HGM] send opening position in FRC to first engine */
7892     if(setup) {
7893           SendToProgram("force\n", cps);
7894           SendBoard(cps, 0);
7895           /* engine is now in force mode! Set flag to wake it up after first move. */
7896           setboardSpoiledMachineBlack = 1;
7897     }
7898
7899     if (cps->sendICS) {
7900       snprintf(buf, sizeof(buf), "ics %s\n", appData.icsActive ? appData.icsHost : "-");
7901       SendToProgram(buf, cps);
7902     }
7903     cps->maybeThinking = FALSE;
7904     cps->offeredDraw = 0;
7905     if (!appData.icsActive) {
7906         SendTimeControl(cps, movesPerSession, timeControl,
7907                         timeIncrement, appData.searchDepth,
7908                         searchTime);
7909     }
7910     if (appData.showThinking
7911         // [HGM] thinking: four options require thinking output to be sent
7912         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
7913                                 ) {
7914         SendToProgram("post\n", cps);
7915     }
7916     SendToProgram("hard\n", cps);
7917     if (!appData.ponderNextMove) {
7918         /* Warning: "easy" is a toggle in GNU Chess, so don't send
7919            it without being sure what state we are in first.  "hard"
7920            is not a toggle, so that one is OK.
7921          */
7922         SendToProgram("easy\n", cps);
7923     }
7924     if (cps->usePing) {
7925       sprintf(buf, "ping %d\n", ++cps->lastPing);
7926       SendToProgram(buf, cps);
7927     }
7928     cps->initDone = TRUE;
7929 }
7930
7931
7932 void
7933 StartChessProgram(cps)
7934      ChessProgramState *cps;
7935 {
7936     char buf[MSG_SIZ];
7937     int err;
7938
7939     if (appData.noChessProgram) return;
7940     cps->initDone = FALSE;
7941
7942     if (strcmp(cps->host, "localhost") == 0) {
7943         err = StartChildProcess(cps->program, cps->dir, &cps->pr);
7944     } else if (*appData.remoteShell == NULLCHAR) {
7945         err = OpenRcmd(cps->host, appData.remoteUser, cps->program, &cps->pr);
7946     } else {
7947         if (*appData.remoteUser == NULLCHAR) {
7948           snprintf(buf, sizeof(buf), "%s %s %s", appData.remoteShell, cps->host,
7949                     cps->program);
7950         } else {
7951           snprintf(buf, sizeof(buf), "%s %s -l %s %s", appData.remoteShell,
7952                     cps->host, appData.remoteUser, cps->program);
7953         }
7954         err = StartChildProcess(buf, "", &cps->pr);
7955     }
7956
7957     if (err != 0) {
7958         sprintf(buf, _("Startup failure on '%s'"), cps->program);
7959         DisplayFatalError(buf, err, 1);
7960         cps->pr = NoProc;
7961         cps->isr = NULL;
7962         return;
7963     }
7964
7965     cps->isr = AddInputSource(cps->pr, TRUE, ReceiveFromProgram, cps);
7966     if (cps->protocolVersion > 1) {
7967       sprintf(buf, "xboard\nprotover %d\n", cps->protocolVersion);
7968       cps->nrOptions = 0; // [HGM] options: clear all engine-specific options
7969       cps->comboCnt = 0;  //                and values of combo boxes
7970       SendToProgram(buf, cps);
7971     } else {
7972       SendToProgram("xboard\n", cps);
7973     }
7974 }
7975
7976
7977 void
7978 TwoMachinesEventIfReady P((void))
7979 {
7980   if (first.lastPing != first.lastPong) {
7981     DisplayMessage("", _("Waiting for first chess program"));
7982     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
7983     return;
7984   }
7985   if (second.lastPing != second.lastPong) {
7986     DisplayMessage("", _("Waiting for second chess program"));
7987     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
7988     return;
7989   }
7990   ThawUI();
7991   TwoMachinesEvent();
7992 }
7993
7994 void
7995 NextMatchGame P((void))
7996 {
7997     int index; /* [HGM] autoinc: step load index during match */
7998     Reset(FALSE, TRUE);
7999     if (*appData.loadGameFile != NULLCHAR) {
8000         index = appData.loadGameIndex;
8001         if(index < 0) { // [HGM] autoinc
8002             lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
8003             if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
8004         }
8005         LoadGameFromFile(appData.loadGameFile,
8006                          index,
8007                          appData.loadGameFile, FALSE);
8008     } else if (*appData.loadPositionFile != NULLCHAR) {
8009         index = appData.loadPositionIndex;
8010         if(index < 0) { // [HGM] autoinc
8011             lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
8012             if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
8013         }
8014         LoadPositionFromFile(appData.loadPositionFile,
8015                              index,
8016                              appData.loadPositionFile);
8017     }
8018     TwoMachinesEventIfReady();
8019 }
8020
8021 void UserAdjudicationEvent( int result )
8022 {
8023     ChessMove gameResult = GameIsDrawn;
8024
8025     if( result > 0 ) {
8026         gameResult = WhiteWins;
8027     }
8028     else if( result < 0 ) {
8029         gameResult = BlackWins;
8030     }
8031
8032     if( gameMode == TwoMachinesPlay ) {
8033         GameEnds( gameResult, "User adjudication", GE_XBOARD );
8034     }
8035 }
8036
8037
8038 // [HGM] save: calculate checksum of game to make games easily identifiable
8039 int StringCheckSum(char *s)
8040 {
8041         int i = 0;
8042         if(s==NULL) return 0;
8043         while(*s) i = i*259 + *s++;
8044         return i;
8045 }
8046
8047 int GameCheckSum()
8048 {
8049         int i, sum=0;
8050         for(i=backwardMostMove; i<forwardMostMove; i++) {
8051                 sum += pvInfoList[i].depth;
8052                 sum += StringCheckSum(parseList[i]);
8053                 sum += StringCheckSum(commentList[i]);
8054                 sum *= 261;
8055         }
8056         if(i>1 && sum==0) sum++; // make sure never zero for non-empty game
8057         return sum + StringCheckSum(commentList[i]);
8058 } // end of save patch
8059
8060 void
8061 GameEnds(result, resultDetails, whosays)
8062      ChessMove result;
8063      char *resultDetails;
8064      int whosays;
8065 {
8066     GameMode nextGameMode;
8067     int isIcsGame;
8068     char buf[MSG_SIZ];
8069
8070     if(endingGame) return; /* [HGM] crash: forbid recursion */
8071     endingGame = 1;
8072
8073     if (appData.debugMode) {
8074       fprintf(debugFP, "GameEnds(%d, %s, %d)\n",
8075               result, resultDetails ? resultDetails : "(null)", whosays);
8076     }
8077
8078     if (appData.icsActive && (whosays == GE_ENGINE || whosays >= GE_ENGINE1)) {
8079         /* If we are playing on ICS, the server decides when the
8080            game is over, but the engine can offer to draw, claim
8081            a draw, or resign.
8082          */
8083 #if ZIPPY
8084         if (appData.zippyPlay && first.initDone) {
8085             if (result == GameIsDrawn) {
8086                 /* In case draw still needs to be claimed */
8087                 SendToICS(ics_prefix);
8088                 SendToICS("draw\n");
8089             } else if (StrCaseStr(resultDetails, "resign")) {
8090                 SendToICS(ics_prefix);
8091                 SendToICS("resign\n");
8092             }
8093         }
8094 #endif
8095         endingGame = 0; /* [HGM] crash */
8096         return;
8097     }
8098
8099     /* If we're loading the game from a file, stop */
8100     if (whosays == GE_FILE) {
8101       (void) StopLoadGameTimer();
8102       gameFileFP = NULL;
8103     }
8104
8105     /* Cancel draw offers */
8106     first.offeredDraw = second.offeredDraw = 0;
8107
8108     /* If this is an ICS game, only ICS can really say it's done;
8109        if not, anyone can. */
8110     isIcsGame = (gameMode == IcsPlayingWhite ||
8111                  gameMode == IcsPlayingBlack ||
8112                  gameMode == IcsObserving    ||
8113                  gameMode == IcsExamining);
8114
8115     if (!isIcsGame || whosays == GE_ICS) {
8116         /* OK -- not an ICS game, or ICS said it was done */
8117         StopClocks();
8118         if (!isIcsGame && !appData.noChessProgram)
8119           SetUserThinkingEnables();
8120
8121         /* [HGM] if a machine claims the game end we verify this claim */
8122         if(gameMode == TwoMachinesPlay && appData.testClaims) {
8123             if(appData.testLegality && whosays >= GE_ENGINE1 ) {
8124                 char claimer;
8125                 ChessMove trueResult = (ChessMove) -1;
8126
8127                 claimer = whosays == GE_ENGINE1 ?      /* color of claimer */
8128                                             first.twoMachinesColor[0] :
8129                                             second.twoMachinesColor[0] ;
8130
8131                 // [HGM] losers: because the logic is becoming a bit hairy, determine true result first
8132                 if(epStatus[forwardMostMove] == EP_CHECKMATE) {
8133                     /* [HGM] verify: engine mate claims accepted if they were flagged */
8134                     trueResult = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins;
8135                 } else
8136                 if(epStatus[forwardMostMove] == EP_WINS) { // added code for games where being mated is a win
8137                     /* [HGM] verify: engine mate claims accepted if they were flagged */
8138                     trueResult = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
8139                 } else
8140                 if(epStatus[forwardMostMove] == EP_STALEMATE) { // only used to indicate draws now
8141                     trueResult = GameIsDrawn; // default; in variants where stalemate loses, Status is CHECKMATE
8142                 }
8143
8144                 // now verify win claims, but not in drop games, as we don't understand those yet
8145                 if( (gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
8146                                                  || gameInfo.variant == VariantGreat) &&
8147                     (result == WhiteWins && claimer == 'w' ||
8148                      result == BlackWins && claimer == 'b'   ) ) { // case to verify: engine claims own win
8149                       if (appData.debugMode) {
8150                         fprintf(debugFP, "result=%d sp=%d move=%d\n",
8151                                 result, epStatus[forwardMostMove], forwardMostMove);
8152                       }
8153                       if(result != trueResult) {
8154                               sprintf(buf, "False win claim: '%s'", resultDetails);
8155                               result = claimer == 'w' ? BlackWins : WhiteWins;
8156                               resultDetails = buf;
8157                       }
8158                 } else
8159                 if( result == GameIsDrawn && epStatus[forwardMostMove] > EP_DRAWS
8160                     && (forwardMostMove <= backwardMostMove ||
8161                         epStatus[forwardMostMove-1] > EP_DRAWS ||
8162                         (claimer=='b')==(forwardMostMove&1))
8163                                                                                   ) {
8164                       /* [HGM] verify: draws that were not flagged are false claims */
8165                       sprintf(buf, "False draw claim: '%s'", resultDetails);
8166                       result = claimer == 'w' ? BlackWins : WhiteWins;
8167                       resultDetails = buf;
8168                 }
8169                 /* (Claiming a loss is accepted no questions asked!) */
8170             }
8171             /* [HGM] bare: don't allow bare King to win */
8172             if((gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
8173                && gameInfo.variant != VariantLosers && gameInfo.variant != VariantGiveaway
8174                && gameInfo.variant != VariantSuicide // [HGM] losers: except in losers, of course...
8175                && result != GameIsDrawn)
8176             {   int i, j, k=0, color = (result==WhiteWins ? (int)WhitePawn : (int)BlackPawn);
8177                 for(j=BOARD_LEFT; j<BOARD_RGHT; j++) for(i=0; i<BOARD_HEIGHT; i++) {
8178                         int p = (int)boards[forwardMostMove][i][j] - color;
8179                         if(p >= 0 && p <= (int)WhiteKing) k++;
8180                 }
8181                 if (appData.debugMode) {
8182                      fprintf(debugFP, "GE(%d, %s, %d) bare king k=%d color=%d\n",
8183                         result, resultDetails ? resultDetails : "(null)", whosays, k, color);
8184                 }
8185                 if(k <= 1) {
8186                         result = GameIsDrawn;
8187                         sprintf(buf, "%s but bare king", resultDetails);
8188                         resultDetails = buf;
8189                 }
8190             }
8191         }
8192
8193
8194         if(serverMoves != NULL && !loadFlag) { char c = '=';
8195             if(result==WhiteWins) c = '+';
8196             if(result==BlackWins) c = '-';
8197             if(resultDetails != NULL)
8198                 fprintf(serverMoves, ";%c;%s\n", c, resultDetails);
8199         }
8200         if (resultDetails != NULL) {
8201             gameInfo.result = result;
8202             gameInfo.resultDetails = StrSave(resultDetails);
8203
8204             /* display last move only if game was not loaded from file */
8205             if ((whosays != GE_FILE) && (currentMove == forwardMostMove))
8206                 DisplayMove(currentMove - 1);
8207
8208             if (forwardMostMove != 0) {
8209                 if (gameMode != PlayFromGameFile && gameMode != EditGame
8210                     && lastSavedGame != GameCheckSum() // [HGM] save: suppress duplicates
8211                                                                 ) {
8212                     if (*appData.saveGameFile != NULLCHAR) {
8213                         SaveGameToFile(appData.saveGameFile, TRUE);
8214                     } else if (appData.autoSaveGames) {
8215                         AutoSaveGame();
8216                     }
8217                     if (*appData.savePositionFile != NULLCHAR) {
8218                         SavePositionToFile(appData.savePositionFile);
8219                     }
8220                 }
8221             }
8222
8223             /* Tell program how game ended in case it is learning */
8224             /* [HGM] Moved this to after saving the PGN, just in case */
8225             /* engine died and we got here through time loss. In that */
8226             /* case we will get a fatal error writing the pipe, which */
8227             /* would otherwise lose us the PGN.                       */
8228             /* [HGM] crash: not needed anymore, but doesn't hurt;     */
8229             /* output during GameEnds should never be fatal anymore   */
8230             if (gameMode == MachinePlaysWhite ||
8231                 gameMode == MachinePlaysBlack ||
8232                 gameMode == TwoMachinesPlay ||
8233                 gameMode == IcsPlayingWhite ||
8234                 gameMode == IcsPlayingBlack ||
8235                 gameMode == BeginningOfGame) {
8236                 char buf[MSG_SIZ];
8237                 sprintf(buf, "result %s {%s}\n", PGNResult(result),
8238                         resultDetails);
8239                 if (first.pr != NoProc) {
8240                     SendToProgram(buf, &first);
8241                 }
8242                 if (second.pr != NoProc &&
8243                     gameMode == TwoMachinesPlay) {
8244                     SendToProgram(buf, &second);
8245                 }
8246             }
8247         }
8248
8249         if (appData.icsActive) {
8250             if (appData.quietPlay &&
8251                 (gameMode == IcsPlayingWhite ||
8252                  gameMode == IcsPlayingBlack)) {
8253                 SendToICS(ics_prefix);
8254                 SendToICS("set shout 1\n");
8255             }
8256             nextGameMode = IcsIdle;
8257             ics_user_moved = FALSE;
8258             /* clean up premove.  It's ugly when the game has ended and the
8259              * premove highlights are still on the board.
8260              */
8261             if (gotPremove) {
8262               gotPremove = FALSE;
8263               ClearPremoveHighlights();
8264               DrawPosition(FALSE, boards[currentMove]);
8265             }
8266             if (whosays == GE_ICS) {
8267                 switch (result) {
8268                 case WhiteWins:
8269                     if (gameMode == IcsPlayingWhite)
8270                         PlayIcsWinSound();
8271                     else if(gameMode == IcsPlayingBlack)
8272                         PlayIcsLossSound();
8273                     break;
8274                 case BlackWins:
8275                     if (gameMode == IcsPlayingBlack)
8276                         PlayIcsWinSound();
8277                     else if(gameMode == IcsPlayingWhite)
8278                         PlayIcsLossSound();
8279                     break;
8280                 case GameIsDrawn:
8281                     PlayIcsDrawSound();
8282                     break;
8283                 default:
8284                     PlayIcsUnfinishedSound();
8285                 }
8286             }
8287         } else if (gameMode == EditGame ||
8288                    gameMode == PlayFromGameFile ||
8289                    gameMode == AnalyzeMode ||
8290                    gameMode == AnalyzeFile) {
8291             nextGameMode = gameMode;
8292         } else {
8293             nextGameMode = EndOfGame;
8294         }
8295         pausing = FALSE;
8296         ModeHighlight();
8297     } else {
8298         nextGameMode = gameMode;
8299     }
8300
8301     if (appData.noChessProgram) {
8302         gameMode = nextGameMode;
8303         ModeHighlight();
8304         endingGame = 0; /* [HGM] crash */
8305         return;
8306     }
8307
8308     if (first.reuse) {
8309         /* Put first chess program into idle state */
8310         if (first.pr != NoProc &&
8311             (gameMode == MachinePlaysWhite ||
8312              gameMode == MachinePlaysBlack ||
8313              gameMode == TwoMachinesPlay ||
8314              gameMode == IcsPlayingWhite ||
8315              gameMode == IcsPlayingBlack ||
8316              gameMode == BeginningOfGame)) {
8317             SendToProgram("force\n", &first);
8318             if (first.usePing) {
8319               char buf[MSG_SIZ];
8320               sprintf(buf, "ping %d\n", ++first.lastPing);
8321               SendToProgram(buf, &first);
8322             }
8323         }
8324     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
8325         /* Kill off first chess program */
8326         if (first.isr != NULL)
8327           RemoveInputSource(first.isr);
8328         first.isr = NULL;
8329
8330         if (first.pr != NoProc) {
8331             ExitAnalyzeMode();
8332             DoSleep( appData.delayBeforeQuit );
8333             SendToProgram("quit\n", &first);
8334             DoSleep( appData.delayAfterQuit );
8335             DestroyChildProcess(first.pr, first.useSigterm);
8336         }
8337         first.pr = NoProc;
8338     }
8339     if (second.reuse) {
8340         /* Put second chess program into idle state */
8341         if (second.pr != NoProc &&
8342             gameMode == TwoMachinesPlay) {
8343             SendToProgram("force\n", &second);
8344             if (second.usePing) {
8345               char buf[MSG_SIZ];
8346               sprintf(buf, "ping %d\n", ++second.lastPing);
8347               SendToProgram(buf, &second);
8348             }
8349         }
8350     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
8351         /* Kill off second chess program */
8352         if (second.isr != NULL)
8353           RemoveInputSource(second.isr);
8354         second.isr = NULL;
8355
8356         if (second.pr != NoProc) {
8357             DoSleep( appData.delayBeforeQuit );
8358             SendToProgram("quit\n", &second);
8359             DoSleep( appData.delayAfterQuit );
8360             DestroyChildProcess(second.pr, second.useSigterm);
8361         }
8362         second.pr = NoProc;
8363     }
8364
8365     if (matchMode && gameMode == TwoMachinesPlay) {
8366         switch (result) {
8367         case WhiteWins:
8368           if (first.twoMachinesColor[0] == 'w') {
8369             first.matchWins++;
8370           } else {
8371             second.matchWins++;
8372           }
8373           break;
8374         case BlackWins:
8375           if (first.twoMachinesColor[0] == 'b') {
8376             first.matchWins++;
8377           } else {
8378             second.matchWins++;
8379           }
8380           break;
8381         default:
8382           break;
8383         }
8384         if (matchGame < appData.matchGames) {
8385             char *tmp;
8386             if(appData.sameColorGames <= 1) { /* [HGM] alternate: suppress color swap */
8387                 tmp = first.twoMachinesColor;
8388                 first.twoMachinesColor = second.twoMachinesColor;
8389                 second.twoMachinesColor = tmp;
8390             }
8391             gameMode = nextGameMode;
8392             matchGame++;
8393             if(appData.matchPause>10000 || appData.matchPause<10)
8394                 appData.matchPause = 10000; /* [HGM] make pause adjustable */
8395             ScheduleDelayedEvent(NextMatchGame, appData.matchPause);
8396             endingGame = 0; /* [HGM] crash */
8397             return;
8398         } else {
8399             char buf[MSG_SIZ];
8400             gameMode = nextGameMode;
8401             sprintf(buf, _("Match %s vs. %s: final score %d-%d-%d"),
8402                     first.tidy, second.tidy,
8403                     first.matchWins, second.matchWins,
8404                     appData.matchGames - (first.matchWins + second.matchWins));
8405             DisplayFatalError(buf, 0, 0);
8406         }
8407     }
8408     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile) &&
8409         !(nextGameMode == AnalyzeMode || nextGameMode == AnalyzeFile))
8410       ExitAnalyzeMode();
8411     gameMode = nextGameMode;
8412     ModeHighlight();
8413     endingGame = 0;  /* [HGM] crash */
8414 }
8415
8416 /* Assumes program was just initialized (initString sent).
8417    Leaves program in force mode. */
8418 void
8419 FeedMovesToProgram(cps, upto)
8420      ChessProgramState *cps;
8421      int upto;
8422 {
8423     int i;
8424
8425     if (appData.debugMode)
8426       fprintf(debugFP, "Feeding %smoves %d through %d to %s chess program\n",
8427               startedFromSetupPosition ? "position and " : "",
8428               backwardMostMove, upto, cps->which);
8429     if(currentlyInitializedVariant != gameInfo.variant) { char buf[MSG_SIZ];
8430         // [HGM] variantswitch: make engine aware of new variant
8431         if(cps->protocolVersion > 1 && StrStr(cps->variants, VariantName(gameInfo.variant)) == NULL)
8432                 return; // [HGM] refrain from feeding moves altogether if variant is unsupported!
8433         sprintf(buf, "variant %s\n", VariantName(gameInfo.variant));
8434         SendToProgram(buf, cps);
8435         currentlyInitializedVariant = gameInfo.variant;
8436     }
8437     SendToProgram("force\n", cps);
8438     if (startedFromSetupPosition) {
8439         SendBoard(cps, backwardMostMove);
8440     if (appData.debugMode) {
8441         fprintf(debugFP, "feedMoves\n");
8442     }
8443     }
8444     for (i = backwardMostMove; i < upto; i++) {
8445         SendMoveToProgram(i, cps);
8446     }
8447 }
8448
8449
8450 void
8451 ResurrectChessProgram()
8452 {
8453      /* The chess program may have exited.
8454         If so, restart it and feed it all the moves made so far. */
8455
8456     if (appData.noChessProgram || first.pr != NoProc) return;
8457
8458     StartChessProgram(&first);
8459     InitChessProgram(&first, FALSE);
8460     FeedMovesToProgram(&first, currentMove);
8461
8462     if (!first.sendTime) {
8463         /* can't tell gnuchess what its clock should read,
8464            so we bow to its notion. */
8465         ResetClocks();
8466         timeRemaining[0][currentMove] = whiteTimeRemaining;
8467         timeRemaining[1][currentMove] = blackTimeRemaining;
8468     }
8469
8470     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile ||
8471                 appData.icsEngineAnalyze) && first.analysisSupport) {
8472       SendToProgram("analyze\n", &first);
8473       first.analyzing = TRUE;
8474     }
8475 }
8476
8477 /*
8478  * Button procedures
8479  */
8480 void
8481 Reset(redraw, init)
8482      int redraw, init;
8483 {
8484     int i;
8485
8486     if (appData.debugMode) {
8487         fprintf(debugFP, "Reset(%d, %d) from gameMode %d\n",
8488                 redraw, init, gameMode);
8489     }
8490     pausing = pauseExamInvalid = FALSE;
8491     startedFromSetupPosition = blackPlaysFirst = FALSE;
8492     firstMove = TRUE;
8493     whiteFlag = blackFlag = FALSE;
8494     userOfferedDraw = FALSE;
8495     hintRequested = bookRequested = FALSE;
8496     first.maybeThinking = FALSE;
8497     second.maybeThinking = FALSE;
8498     first.bookSuspend = FALSE; // [HGM] book
8499     second.bookSuspend = FALSE;
8500     thinkOutput[0] = NULLCHAR;
8501     lastHint[0] = NULLCHAR;
8502     ClearGameInfo(&gameInfo);
8503     gameInfo.variant = StringToVariant(appData.variant);
8504     ics_user_moved = ics_clock_paused = FALSE;
8505     ics_getting_history = H_FALSE;
8506     ics_gamenum = -1;
8507     white_holding[0] = black_holding[0] = NULLCHAR;
8508     ClearProgramStats();
8509     opponentKibitzes = FALSE; // [HGM] kibitz: do not reserve space in engine-output window in zippy mode
8510
8511     ResetFrontEnd();
8512     ClearHighlights();
8513     flipView = appData.flipView;
8514     ClearPremoveHighlights();
8515     gotPremove = FALSE;
8516     alarmSounded = FALSE;
8517
8518     GameEnds((ChessMove) 0, NULL, GE_PLAYER);
8519     if(appData.serverMovesName != NULL) {
8520         /* [HGM] prepare to make moves file for broadcasting */
8521         clock_t t = clock();
8522         if(serverMoves != NULL) fclose(serverMoves);
8523         serverMoves = fopen(appData.serverMovesName, "r");
8524         if(serverMoves != NULL) {
8525             fclose(serverMoves);
8526             /* delay 15 sec before overwriting, so all clients can see end */
8527             while(clock()-t < appData.serverPause*CLOCKS_PER_SEC);
8528         }
8529         serverMoves = fopen(appData.serverMovesName, "w");
8530     }
8531
8532     ExitAnalyzeMode();
8533     gameMode = BeginningOfGame;
8534     ModeHighlight();
8535     if(appData.icsActive) gameInfo.variant = VariantNormal;
8536     currentMove = forwardMostMove = backwardMostMove = 0;
8537     InitPosition(redraw);
8538     for (i = 0; i < MAX_MOVES; i++) {
8539         if (commentList[i] != NULL) {
8540             free(commentList[i]);
8541             commentList[i] = NULL;
8542         }
8543     }
8544     ResetClocks();
8545     timeRemaining[0][0] = whiteTimeRemaining;
8546     timeRemaining[1][0] = blackTimeRemaining;
8547     if (first.pr == NULL) {
8548         StartChessProgram(&first);
8549     }
8550     if (init) {
8551             InitChessProgram(&first, startedFromSetupPosition);
8552     }
8553     DisplayTitle("");
8554     DisplayMessage("", "");
8555     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
8556     lastSavedGame = 0; // [HGM] save: make sure next game counts as unsaved
8557 }
8558
8559 void
8560 AutoPlayGameLoop()
8561 {
8562     for (;;) {
8563         if (!AutoPlayOneMove())
8564           return;
8565         if (matchMode || appData.timeDelay == 0)
8566           continue;
8567         if (appData.timeDelay < 0 || gameMode == AnalyzeFile)
8568           return;
8569         StartLoadGameTimer((long)(1000.0 * appData.timeDelay));
8570         break;
8571     }
8572 }
8573
8574
8575 int
8576 AutoPlayOneMove()
8577 {
8578     int fromX, fromY, toX, toY;
8579
8580     if (appData.debugMode) {
8581       fprintf(debugFP, "AutoPlayOneMove(): current %d\n", currentMove);
8582     }
8583
8584     if (gameMode != PlayFromGameFile)
8585       return FALSE;
8586
8587     if (currentMove >= forwardMostMove) {
8588       gameMode = EditGame;
8589       ModeHighlight();
8590
8591       /* [AS] Clear current move marker at the end of a game */
8592       /* HistorySet(parseList, backwardMostMove, forwardMostMove, -1); */
8593
8594       return FALSE;
8595     }
8596
8597     toX = moveList[currentMove][2] - AAA;
8598     toY = moveList[currentMove][3] - ONE;
8599
8600     if (moveList[currentMove][1] == '@') {
8601         if (appData.highlightLastMove) {
8602             SetHighlights(-1, -1, toX, toY);
8603         }
8604     } else {
8605         fromX = moveList[currentMove][0] - AAA;
8606         fromY = moveList[currentMove][1] - ONE;
8607
8608         HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove); /* [AS] */
8609
8610         AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
8611
8612         if (appData.highlightLastMove) {
8613             SetHighlights(fromX, fromY, toX, toY);
8614         }
8615     }
8616     DisplayMove(currentMove);
8617     SendMoveToProgram(currentMove++, &first);
8618     DisplayBothClocks();
8619     DrawPosition(FALSE, boards[currentMove]);
8620     // [HGM] PV info: always display, routine tests if empty
8621     DisplayComment(currentMove - 1, commentList[currentMove]);
8622     return TRUE;
8623 }
8624
8625
8626 int
8627 LoadGameOneMove(readAhead)
8628      ChessMove readAhead;
8629 {
8630     int fromX = 0, fromY = 0, toX = 0, toY = 0, done;
8631     char promoChar = NULLCHAR;
8632     ChessMove moveType;
8633     char move[MSG_SIZ];
8634     char *p, *q;
8635
8636     if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile &&
8637         gameMode != AnalyzeMode && gameMode != Training) {
8638         gameFileFP = NULL;
8639         return FALSE;
8640     }
8641
8642     yyboardindex = forwardMostMove;
8643     if (readAhead != (ChessMove)0) {
8644       moveType = readAhead;
8645     } else {
8646       if (gameFileFP == NULL)
8647           return FALSE;
8648       moveType = (ChessMove) yylex();
8649     }
8650
8651     done = FALSE;
8652     switch (moveType) {
8653       case Comment:
8654         if (appData.debugMode)
8655           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
8656         p = yy_text;
8657         if (*p == '{' || *p == '[' || *p == '(') {
8658             p[strlen(p) - 1] = NULLCHAR;
8659             p++;
8660         }
8661
8662         /* append the comment but don't display it */
8663         while (*p == '\n') p++;
8664         AppendComment(currentMove, p);
8665         return TRUE;
8666
8667       case WhiteCapturesEnPassant:
8668       case BlackCapturesEnPassant:
8669       case WhitePromotionChancellor:
8670       case BlackPromotionChancellor:
8671       case WhitePromotionArchbishop:
8672       case BlackPromotionArchbishop:
8673       case WhitePromotionCentaur:
8674       case BlackPromotionCentaur:
8675       case WhitePromotionQueen:
8676       case BlackPromotionQueen:
8677       case WhitePromotionRook:
8678       case BlackPromotionRook:
8679       case WhitePromotionBishop:
8680       case BlackPromotionBishop:
8681       case WhitePromotionKnight:
8682       case BlackPromotionKnight:
8683       case WhitePromotionKing:
8684       case BlackPromotionKing:
8685       case NormalMove:
8686       case WhiteKingSideCastle:
8687       case WhiteQueenSideCastle:
8688       case BlackKingSideCastle:
8689       case BlackQueenSideCastle:
8690       case WhiteKingSideCastleWild:
8691       case WhiteQueenSideCastleWild:
8692       case BlackKingSideCastleWild:
8693       case BlackQueenSideCastleWild:
8694       /* PUSH Fabien */
8695       case WhiteHSideCastleFR:
8696       case WhiteASideCastleFR:
8697       case BlackHSideCastleFR:
8698       case BlackASideCastleFR:
8699       /* POP Fabien */
8700         if (appData.debugMode)
8701           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
8702         fromX = currentMoveString[0] - AAA;
8703         fromY = currentMoveString[1] - ONE;
8704         toX = currentMoveString[2] - AAA;
8705         toY = currentMoveString[3] - ONE;
8706         promoChar = currentMoveString[4];
8707         break;
8708
8709       case WhiteDrop:
8710       case BlackDrop:
8711         if (appData.debugMode)
8712           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
8713         fromX = moveType == WhiteDrop ?
8714           (int) CharToPiece(ToUpper(currentMoveString[0])) :
8715         (int) CharToPiece(ToLower(currentMoveString[0]));
8716         fromY = DROP_RANK;
8717         toX = currentMoveString[2] - AAA;
8718         toY = currentMoveString[3] - ONE;
8719         break;
8720
8721       case WhiteWins:
8722       case BlackWins:
8723       case GameIsDrawn:
8724       case GameUnfinished:
8725         if (appData.debugMode)
8726           fprintf(debugFP, "Parsed game end: %s\n", yy_text);
8727         p = strchr(yy_text, '{');
8728         if (p == NULL) p = strchr(yy_text, '(');
8729         if (p == NULL) {
8730             p = yy_text;
8731             if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
8732         } else {
8733             q = strchr(p, *p == '{' ? '}' : ')');
8734             if (q != NULL) *q = NULLCHAR;
8735             p++;
8736         }
8737         GameEnds(moveType, p, GE_FILE);
8738         done = TRUE;
8739         if (cmailMsgLoaded) {
8740             ClearHighlights();
8741             flipView = WhiteOnMove(currentMove);
8742             if (moveType == GameUnfinished) flipView = !flipView;
8743             if (appData.debugMode)
8744               fprintf(debugFP, "Setting flipView to %d\n", flipView) ;
8745         }
8746         break;
8747
8748       case (ChessMove) 0:       /* end of file */
8749         if (appData.debugMode)
8750           fprintf(debugFP, "Parser hit end of file\n");
8751         switch (MateTest(boards[currentMove], PosFlags(currentMove),
8752                          EP_UNKNOWN, castlingRights[currentMove]) ) {
8753           case MT_NONE:
8754           case MT_CHECK:
8755             break;
8756           case MT_CHECKMATE:
8757           case MT_STAINMATE:
8758             if (WhiteOnMove(currentMove)) {
8759                 GameEnds(BlackWins, "Black mates", GE_FILE);
8760             } else {
8761                 GameEnds(WhiteWins, "White mates", GE_FILE);
8762             }
8763             break;
8764           case MT_STALEMATE:
8765             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
8766             break;
8767         }
8768         done = TRUE;
8769         break;
8770
8771       case MoveNumberOne:
8772         if (lastLoadGameStart == GNUChessGame) {
8773             /* GNUChessGames have numbers, but they aren't move numbers */
8774             if (appData.debugMode)
8775               fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
8776                       yy_text, (int) moveType);
8777             return LoadGameOneMove((ChessMove)0); /* tail recursion */
8778         }
8779         /* else fall thru */
8780
8781       case XBoardGame:
8782       case GNUChessGame:
8783       case PGNTag:
8784         /* Reached start of next game in file */
8785         if (appData.debugMode)
8786           fprintf(debugFP, "Parsed start of next game: %s\n", yy_text);
8787         switch (MateTest(boards[currentMove], PosFlags(currentMove),
8788                          EP_UNKNOWN, castlingRights[currentMove]) ) {
8789           case MT_NONE:
8790           case MT_CHECK:
8791             break;
8792           case MT_CHECKMATE:
8793           case MT_STAINMATE:
8794             if (WhiteOnMove(currentMove)) {
8795                 GameEnds(BlackWins, "Black mates", GE_FILE);
8796             } else {
8797                 GameEnds(WhiteWins, "White mates", GE_FILE);
8798             }
8799             break;
8800           case MT_STALEMATE:
8801             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
8802             break;
8803         }
8804         done = TRUE;
8805         break;
8806
8807       case PositionDiagram:     /* should not happen; ignore */
8808       case ElapsedTime:         /* ignore */
8809       case NAG:                 /* ignore */
8810         if (appData.debugMode)
8811           fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
8812                   yy_text, (int) moveType);
8813         return LoadGameOneMove((ChessMove)0); /* tail recursion */
8814
8815       case IllegalMove:
8816         if (appData.testLegality) {
8817             if (appData.debugMode)
8818               fprintf(debugFP, "Parsed IllegalMove: %s\n", yy_text);
8819             sprintf(move, _("Illegal move: %d.%s%s"),
8820                     (forwardMostMove / 2) + 1,
8821                     WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
8822             DisplayError(move, 0);
8823             done = TRUE;
8824         } else {
8825             if (appData.debugMode)
8826               fprintf(debugFP, "Parsed %s into IllegalMove %s\n",
8827                       yy_text, currentMoveString);
8828             fromX = currentMoveString[0] - AAA;
8829             fromY = currentMoveString[1] - ONE;
8830             toX = currentMoveString[2] - AAA;
8831             toY = currentMoveString[3] - ONE;
8832             promoChar = currentMoveString[4];
8833         }
8834         break;
8835
8836       case AmbiguousMove:
8837         if (appData.debugMode)
8838           fprintf(debugFP, "Parsed AmbiguousMove: %s\n", yy_text);
8839         sprintf(move, _("Ambiguous move: %d.%s%s"),
8840                 (forwardMostMove / 2) + 1,
8841                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
8842         DisplayError(move, 0);
8843         done = TRUE;
8844         break;
8845
8846       default:
8847       case ImpossibleMove:
8848         if (appData.debugMode)
8849           fprintf(debugFP, "Parsed ImpossibleMove (type = %d): %s\n", moveType, yy_text);
8850         sprintf(move, _("Illegal move: %d.%s%s"),
8851                 (forwardMostMove / 2) + 1,
8852                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
8853         DisplayError(move, 0);
8854         done = TRUE;
8855         break;
8856     }
8857
8858     if (done) {
8859         if (appData.matchMode || (appData.timeDelay == 0 && !pausing)) {
8860             DrawPosition(FALSE, boards[currentMove]);
8861             DisplayBothClocks();
8862             if (!appData.matchMode) // [HGM] PV info: routine tests if empty
8863               DisplayComment(currentMove - 1, commentList[currentMove]);
8864         }
8865         (void) StopLoadGameTimer();
8866         gameFileFP = NULL;
8867         cmailOldMove = forwardMostMove;
8868         return FALSE;
8869     } else {
8870         /* currentMoveString is set as a side-effect of yylex */
8871         strcat(currentMoveString, "\n");
8872         strcpy(moveList[forwardMostMove], currentMoveString);
8873
8874         thinkOutput[0] = NULLCHAR;
8875         MakeMove(fromX, fromY, toX, toY, promoChar);
8876         currentMove = forwardMostMove;
8877         return TRUE;
8878     }
8879 }
8880
8881 /* Load the nth game from the given file */
8882 int
8883 LoadGameFromFile(filename, n, title, useList)
8884      char *filename;
8885      int n;
8886      char *title;
8887      /*Boolean*/ int useList;
8888 {
8889     FILE *f;
8890     char buf[MSG_SIZ];
8891
8892     if (strcmp(filename, "-") == 0) {
8893         f = stdin;
8894         title = "stdin";
8895     } else {
8896         f = fopen(filename, "rb");
8897         if (f == NULL) {
8898           snprintf(buf, sizeof(buf),  _("Can't open \"%s\""), filename);
8899             DisplayError(buf, errno);
8900             return FALSE;
8901         }
8902     }
8903     if (fseek(f, 0, 0) == -1) {
8904         /* f is not seekable; probably a pipe */
8905         useList = FALSE;
8906     }
8907     if (useList && n == 0) {
8908         int error = GameListBuild(f);
8909         if (error) {
8910             DisplayError(_("Cannot build game list"), error);
8911         } else if (!ListEmpty(&gameList) &&
8912                    ((ListGame *) gameList.tailPred)->number > 1) {
8913             GameListPopUp(f, title);
8914             return TRUE;
8915         }
8916         GameListDestroy();
8917         n = 1;
8918     }
8919     if (n == 0) n = 1;
8920     return LoadGame(f, n, title, FALSE);
8921 }
8922
8923
8924 void
8925 MakeRegisteredMove()
8926 {
8927     int fromX, fromY, toX, toY;
8928     char promoChar;
8929     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
8930         switch (cmailMoveType[lastLoadGameNumber - 1]) {
8931           case CMAIL_MOVE:
8932           case CMAIL_DRAW:
8933             if (appData.debugMode)
8934               fprintf(debugFP, "Restoring %s for game %d\n",
8935                       cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
8936
8937             thinkOutput[0] = NULLCHAR;
8938             strcpy(moveList[currentMove], cmailMove[lastLoadGameNumber - 1]);
8939             fromX = cmailMove[lastLoadGameNumber - 1][0] - AAA;
8940             fromY = cmailMove[lastLoadGameNumber - 1][1] - ONE;
8941             toX = cmailMove[lastLoadGameNumber - 1][2] - AAA;
8942             toY = cmailMove[lastLoadGameNumber - 1][3] - ONE;
8943             promoChar = cmailMove[lastLoadGameNumber - 1][4];
8944             MakeMove(fromX, fromY, toX, toY, promoChar);
8945             ShowMove(fromX, fromY, toX, toY);
8946
8947             switch (MateTest(boards[currentMove], PosFlags(currentMove),
8948                              EP_UNKNOWN, castlingRights[currentMove]) ) {
8949               case MT_NONE:
8950               case MT_CHECK:
8951                 break;
8952
8953               case MT_CHECKMATE:
8954               case MT_STAINMATE:
8955                 if (WhiteOnMove(currentMove)) {
8956                     GameEnds(BlackWins, "Black mates", GE_PLAYER);
8957                 } else {
8958                     GameEnds(WhiteWins, "White mates", GE_PLAYER);
8959                 }
8960                 break;
8961
8962               case MT_STALEMATE:
8963                 GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
8964                 break;
8965             }
8966
8967             break;
8968
8969           case CMAIL_RESIGN:
8970             if (WhiteOnMove(currentMove)) {
8971                 GameEnds(BlackWins, "White resigns", GE_PLAYER);
8972             } else {
8973                 GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
8974             }
8975             break;
8976
8977           case CMAIL_ACCEPT:
8978             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
8979             break;
8980
8981           default:
8982             break;
8983         }
8984     }
8985
8986     return;
8987 }
8988
8989 /* Wrapper around LoadGame for use when a Cmail message is loaded */
8990 int
8991 CmailLoadGame(f, gameNumber, title, useList)
8992      FILE *f;
8993      int gameNumber;
8994      char *title;
8995      int useList;
8996 {
8997     int retVal;
8998
8999     if (gameNumber > nCmailGames) {
9000         DisplayError(_("No more games in this message"), 0);
9001         return FALSE;
9002     }
9003     if (f == lastLoadGameFP) {
9004         int offset = gameNumber - lastLoadGameNumber;
9005         if (offset == 0) {
9006             cmailMsg[0] = NULLCHAR;
9007             if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
9008                 cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
9009                 nCmailMovesRegistered--;
9010             }
9011             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
9012             if (cmailResult[lastLoadGameNumber - 1] == CMAIL_NEW_RESULT) {
9013                 cmailResult[lastLoadGameNumber - 1] = CMAIL_NOT_RESULT;
9014             }
9015         } else {
9016             if (! RegisterMove()) return FALSE;
9017         }
9018     }
9019
9020     retVal = LoadGame(f, gameNumber, title, useList);
9021
9022     /* Make move registered during previous look at this game, if any */
9023     MakeRegisteredMove();
9024
9025     if (cmailCommentList[lastLoadGameNumber - 1] != NULL) {
9026         commentList[currentMove]
9027           = StrSave(cmailCommentList[lastLoadGameNumber - 1]);
9028         DisplayComment(currentMove - 1, commentList[currentMove]);
9029     }
9030
9031     return retVal;
9032 }
9033
9034 /* Support for LoadNextGame, LoadPreviousGame, ReloadSameGame */
9035 int
9036 ReloadGame(offset)
9037      int offset;
9038 {
9039     int gameNumber = lastLoadGameNumber + offset;
9040     if (lastLoadGameFP == NULL) {
9041         DisplayError(_("No game has been loaded yet"), 0);
9042         return FALSE;
9043     }
9044     if (gameNumber <= 0) {
9045         DisplayError(_("Can't back up any further"), 0);
9046         return FALSE;
9047     }
9048     if (cmailMsgLoaded) {
9049         return CmailLoadGame(lastLoadGameFP, gameNumber,
9050                              lastLoadGameTitle, lastLoadGameUseList);
9051     } else {
9052         return LoadGame(lastLoadGameFP, gameNumber,
9053                         lastLoadGameTitle, lastLoadGameUseList);
9054     }
9055 }
9056
9057
9058
9059 /* Load the nth game from open file f */
9060 int
9061 LoadGame(f, gameNumber, title, useList)
9062      FILE *f;
9063      int gameNumber;
9064      char *title;
9065      int useList;
9066 {
9067     ChessMove cm;
9068     char buf[MSG_SIZ];
9069     int gn = gameNumber;
9070     ListGame *lg = NULL;
9071     int numPGNTags = 0;
9072     int err;
9073     GameMode oldGameMode;
9074     VariantClass oldVariant = gameInfo.variant; /* [HGM] PGNvariant */
9075
9076     if (appData.debugMode)
9077         fprintf(debugFP, "LoadGame(): on entry, gameMode %d\n", gameMode);
9078
9079     if (gameMode == Training )
9080         SetTrainingModeOff();
9081
9082     oldGameMode = gameMode;
9083     if (gameMode != BeginningOfGame) {
9084       Reset(FALSE, TRUE);
9085     }
9086
9087     gameFileFP = f;
9088     if (lastLoadGameFP != NULL && lastLoadGameFP != f) {
9089         fclose(lastLoadGameFP);
9090     }
9091
9092     if (useList) {
9093         lg = (ListGame *) ListElem(&gameList, gameNumber-1);
9094
9095         if (lg) {
9096             fseek(f, lg->offset, 0);
9097             GameListHighlight(gameNumber);
9098             gn = 1;
9099         }
9100         else {
9101             DisplayError(_("Game number out of range"), 0);
9102             return FALSE;
9103         }
9104     } else {
9105         GameListDestroy();
9106         if (fseek(f, 0, 0) == -1) {
9107             if (f == lastLoadGameFP ?
9108                 gameNumber == lastLoadGameNumber + 1 :
9109                 gameNumber == 1) {
9110                 gn = 1;
9111             } else {
9112                 DisplayError(_("Can't seek on game file"), 0);
9113                 return FALSE;
9114             }
9115         }
9116     }
9117     lastLoadGameFP = f;
9118     lastLoadGameNumber = gameNumber;
9119     strcpy(lastLoadGameTitle, title);
9120     lastLoadGameUseList = useList;
9121
9122     yynewfile(f);
9123
9124     if (lg && lg->gameInfo.white && lg->gameInfo.black) {
9125       snprintf(buf, sizeof(buf), "%s vs. %s", lg->gameInfo.white,
9126                 lg->gameInfo.black);
9127             DisplayTitle(buf);
9128     } else if (*title != NULLCHAR) {
9129         if (gameNumber > 1) {
9130             sprintf(buf, "%s %d", title, gameNumber);
9131             DisplayTitle(buf);
9132         } else {
9133             DisplayTitle(title);
9134         }
9135     }
9136
9137     if (gameMode != AnalyzeFile && gameMode != AnalyzeMode) {
9138         gameMode = PlayFromGameFile;
9139         ModeHighlight();
9140     }
9141
9142     currentMove = forwardMostMove = backwardMostMove = 0;
9143     CopyBoard(boards[0], initialPosition);
9144     StopClocks();
9145
9146     /*
9147      * Skip the first gn-1 games in the file.
9148      * Also skip over anything that precedes an identifiable
9149      * start of game marker, to avoid being confused by
9150      * garbage at the start of the file.  Currently
9151      * recognized start of game markers are the move number "1",
9152      * the pattern "gnuchess .* game", the pattern
9153      * "^[#;%] [^ ]* game file", and a PGN tag block.
9154      * A game that starts with one of the latter two patterns
9155      * will also have a move number 1, possibly
9156      * following a position diagram.
9157      * 5-4-02: Let's try being more lenient and allowing a game to
9158      * start with an unnumbered move.  Does that break anything?
9159      */
9160     cm = lastLoadGameStart = (ChessMove) 0;
9161     while (gn > 0) {
9162         yyboardindex = forwardMostMove;
9163         cm = (ChessMove) yylex();
9164         switch (cm) {
9165           case (ChessMove) 0:
9166             if (cmailMsgLoaded) {
9167                 nCmailGames = CMAIL_MAX_GAMES - gn;
9168             } else {
9169                 Reset(TRUE, TRUE);
9170                 DisplayError(_("Game not found in file"), 0);
9171             }
9172             return FALSE;
9173
9174           case GNUChessGame:
9175           case XBoardGame:
9176             gn--;
9177             lastLoadGameStart = cm;
9178             break;
9179
9180           case MoveNumberOne:
9181             switch (lastLoadGameStart) {
9182               case GNUChessGame:
9183               case XBoardGame:
9184               case PGNTag:
9185                 break;
9186               case MoveNumberOne:
9187               case (ChessMove) 0:
9188                 gn--;           /* count this game */
9189                 lastLoadGameStart = cm;
9190                 break;
9191               default:
9192                 /* impossible */
9193                 break;
9194             }
9195             break;
9196
9197           case PGNTag:
9198             switch (lastLoadGameStart) {
9199               case GNUChessGame:
9200               case PGNTag:
9201               case MoveNumberOne:
9202               case (ChessMove) 0:
9203                 gn--;           /* count this game */
9204                 lastLoadGameStart = cm;
9205                 break;
9206               case XBoardGame:
9207                 lastLoadGameStart = cm; /* game counted already */
9208                 break;
9209               default:
9210                 /* impossible */
9211                 break;
9212             }
9213             if (gn > 0) {
9214                 do {
9215                     yyboardindex = forwardMostMove;
9216                     cm = (ChessMove) yylex();
9217                 } while (cm == PGNTag || cm == Comment);
9218             }
9219             break;
9220
9221           case WhiteWins:
9222           case BlackWins:
9223           case GameIsDrawn:
9224             if (cmailMsgLoaded && (CMAIL_MAX_GAMES == lastLoadGameNumber)) {
9225                 if (   cmailResult[CMAIL_MAX_GAMES - gn - 1]
9226                     != CMAIL_OLD_RESULT) {
9227                     nCmailResults ++ ;
9228                     cmailResult[  CMAIL_MAX_GAMES
9229                                 - gn - 1] = CMAIL_OLD_RESULT;
9230                 }
9231             }
9232             break;
9233
9234           case NormalMove:
9235             /* Only a NormalMove can be at the start of a game
9236              * without a position diagram. */
9237             if (lastLoadGameStart == (ChessMove) 0) {
9238               gn--;
9239               lastLoadGameStart = MoveNumberOne;
9240             }
9241             break;
9242
9243           default:
9244             break;
9245         }
9246     }
9247
9248     if (appData.debugMode)
9249       fprintf(debugFP, "Parsed game start '%s' (%d)\n", yy_text, (int) cm);
9250
9251     if (cm == XBoardGame) {
9252         /* Skip any header junk before position diagram and/or move 1 */
9253         for (;;) {
9254             yyboardindex = forwardMostMove;
9255             cm = (ChessMove) yylex();
9256
9257             if (cm == (ChessMove) 0 ||
9258                 cm == GNUChessGame || cm == XBoardGame) {
9259                 /* Empty game; pretend end-of-file and handle later */
9260                 cm = (ChessMove) 0;
9261                 break;
9262             }
9263
9264             if (cm == MoveNumberOne || cm == PositionDiagram ||
9265                 cm == PGNTag || cm == Comment)
9266               break;
9267         }
9268     } else if (cm == GNUChessGame) {
9269         if (gameInfo.event != NULL) {
9270             free(gameInfo.event);
9271         }
9272         gameInfo.event = StrSave(yy_text);
9273     }
9274
9275     startedFromSetupPosition = FALSE;
9276     while (cm == PGNTag) {
9277         if (appData.debugMode)
9278           fprintf(debugFP, "Parsed PGNTag: %s\n", yy_text);
9279         err = ParsePGNTag(yy_text, &gameInfo);
9280         if (!err) numPGNTags++;
9281
9282         /* [HGM] PGNvariant: automatically switch to variant given in PGN tag */
9283         if(gameInfo.variant != oldVariant) {
9284             startedFromPositionFile = FALSE; /* [HGM] loadPos: variant switch likely makes position invalid */
9285             InitPosition(TRUE);
9286             oldVariant = gameInfo.variant;
9287             if (appData.debugMode)
9288               fprintf(debugFP, "New variant %d\n", (int) oldVariant);
9289         }
9290
9291
9292         if (gameInfo.fen != NULL) {
9293           Board initial_position;
9294           startedFromSetupPosition = TRUE;
9295           if (!ParseFEN(initial_position, &blackPlaysFirst, gameInfo.fen)) {
9296             Reset(TRUE, TRUE);
9297             DisplayError(_("Bad FEN position in file"), 0);
9298             return FALSE;
9299           }
9300           CopyBoard(boards[0], initial_position);
9301           if (blackPlaysFirst) {
9302             currentMove = forwardMostMove = backwardMostMove = 1;
9303             CopyBoard(boards[1], initial_position);
9304             strcpy(moveList[0], "");
9305             strcpy(parseList[0], "");
9306             timeRemaining[0][1] = whiteTimeRemaining;
9307             timeRemaining[1][1] = blackTimeRemaining;
9308             if (commentList[0] != NULL) {
9309               commentList[1] = commentList[0];
9310               commentList[0] = NULL;
9311             }
9312           } else {
9313             currentMove = forwardMostMove = backwardMostMove = 0;
9314           }
9315           /* [HGM] copy FEN attributes as well. Bugfix 4.3.14m and 4.3.15e: moved to after 'blackPlaysFirst' */
9316           {   int i;
9317               initialRulePlies = FENrulePlies;
9318               epStatus[forwardMostMove] = FENepStatus;
9319               for( i=0; i< nrCastlingRights; i++ )
9320                   initialRights[i] = castlingRights[forwardMostMove][i] = FENcastlingRights[i];
9321           }
9322           yyboardindex = forwardMostMove;
9323           free(gameInfo.fen);
9324           gameInfo.fen = NULL;
9325         }
9326
9327         yyboardindex = forwardMostMove;
9328         cm = (ChessMove) yylex();
9329
9330         /* Handle comments interspersed among the tags */
9331         while (cm == Comment) {
9332             char *p;
9333             if (appData.debugMode)
9334               fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
9335             p = yy_text;
9336             if (*p == '{' || *p == '[' || *p == '(') {
9337                 p[strlen(p) - 1] = NULLCHAR;
9338                 p++;
9339             }
9340             while (*p == '\n') p++;
9341             AppendComment(currentMove, p);
9342             yyboardindex = forwardMostMove;
9343             cm = (ChessMove) yylex();
9344         }
9345     }
9346
9347     /* don't rely on existence of Event tag since if game was
9348      * pasted from clipboard the Event tag may not exist
9349      */
9350     if (numPGNTags > 0){
9351         char *tags;
9352         if (gameInfo.variant == VariantNormal) {
9353           gameInfo.variant = StringToVariant(gameInfo.event);
9354         }
9355         if (!matchMode) {
9356           if( appData.autoDisplayTags ) {
9357             tags = PGNTags(&gameInfo);
9358             TagsPopUp(tags, CmailMsg());
9359             free(tags);
9360           }
9361         }
9362     } else {
9363         /* Make something up, but don't display it now */
9364         SetGameInfo();
9365         TagsPopDown();
9366     }
9367
9368     if (cm == PositionDiagram) {
9369         int i, j;
9370         char *p;
9371         Board initial_position;
9372
9373         if (appData.debugMode)
9374           fprintf(debugFP, "Parsed PositionDiagram: %s\n", yy_text);
9375
9376         if (!startedFromSetupPosition) {
9377             p = yy_text;
9378             for (i = BOARD_HEIGHT - 1; i >= 0; i--)
9379               for (j = BOARD_LEFT; j < BOARD_RGHT; p++)
9380                 switch (*p) {
9381                   case '[':
9382                   case '-':
9383                   case ' ':
9384                   case '\t':
9385                   case '\n':
9386                   case '\r':
9387                     break;
9388                   default:
9389                     initial_position[i][j++] = CharToPiece(*p);
9390                     break;
9391                 }
9392             while (*p == ' ' || *p == '\t' ||
9393                    *p == '\n' || *p == '\r') p++;
9394
9395             if (strncmp(p, "black", strlen("black"))==0)
9396               blackPlaysFirst = TRUE;
9397             else
9398               blackPlaysFirst = FALSE;
9399             startedFromSetupPosition = TRUE;
9400
9401             CopyBoard(boards[0], initial_position);
9402             if (blackPlaysFirst) {
9403                 currentMove = forwardMostMove = backwardMostMove = 1;
9404                 CopyBoard(boards[1], initial_position);
9405                 strcpy(moveList[0], "");
9406                 strcpy(parseList[0], "");
9407                 timeRemaining[0][1] = whiteTimeRemaining;
9408                 timeRemaining[1][1] = blackTimeRemaining;
9409                 if (commentList[0] != NULL) {
9410                     commentList[1] = commentList[0];
9411                     commentList[0] = NULL;
9412                 }
9413             } else {
9414                 currentMove = forwardMostMove = backwardMostMove = 0;
9415             }
9416         }
9417         yyboardindex = forwardMostMove;
9418         cm = (ChessMove) yylex();
9419     }
9420
9421     if (first.pr == NoProc) {
9422         StartChessProgram(&first);
9423     }
9424     InitChessProgram(&first, FALSE);
9425     SendToProgram("force\n", &first);
9426     if (startedFromSetupPosition) {
9427         SendBoard(&first, forwardMostMove);
9428     if (appData.debugMode) {
9429         fprintf(debugFP, "Load Game\n");
9430     }
9431         DisplayBothClocks();
9432     }
9433
9434     /* [HGM] server: flag to write setup moves in broadcast file as one */
9435     loadFlag = appData.suppressLoadMoves;
9436
9437     while (cm == Comment) {
9438         char *p;
9439         if (appData.debugMode)
9440           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
9441         p = yy_text;
9442         if (*p == '{' || *p == '[' || *p == '(') {
9443             p[strlen(p) - 1] = NULLCHAR;
9444             p++;
9445         }
9446         while (*p == '\n') p++;
9447         AppendComment(currentMove, p);
9448         yyboardindex = forwardMostMove;
9449         cm = (ChessMove) yylex();
9450     }
9451
9452     if ((cm == (ChessMove) 0 && lastLoadGameStart != (ChessMove) 0) ||
9453         cm == WhiteWins || cm == BlackWins ||
9454         cm == GameIsDrawn || cm == GameUnfinished) {
9455         DisplayMessage("", _("No moves in game"));
9456         if (cmailMsgLoaded) {
9457             if (appData.debugMode)
9458               fprintf(debugFP, "Setting flipView to %d.\n", FALSE);
9459             ClearHighlights();
9460             flipView = FALSE;
9461         }
9462         DrawPosition(FALSE, boards[currentMove]);
9463         DisplayBothClocks();
9464         gameMode = EditGame;
9465         ModeHighlight();
9466         gameFileFP = NULL;
9467         cmailOldMove = 0;
9468         return TRUE;
9469     }
9470
9471     // [HGM] PV info: routine tests if comment empty
9472     if (!matchMode && (pausing || appData.timeDelay != 0)) {
9473         DisplayComment(currentMove - 1, commentList[currentMove]);
9474     }
9475     if (!matchMode && appData.timeDelay != 0)
9476       DrawPosition(FALSE, boards[currentMove]);
9477
9478     if (gameMode == AnalyzeFile || gameMode == AnalyzeMode) {
9479       programStats.ok_to_send = 1;
9480     }
9481
9482     /* if the first token after the PGN tags is a move
9483      * and not move number 1, retrieve it from the parser
9484      */
9485     if (cm != MoveNumberOne)
9486         LoadGameOneMove(cm);
9487
9488     /* load the remaining moves from the file */
9489     while (LoadGameOneMove((ChessMove)0)) {
9490       timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
9491       timeRemaining[1][forwardMostMove] = blackTimeRemaining;
9492     }
9493
9494     /* rewind to the start of the game */
9495     currentMove = backwardMostMove;
9496
9497     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
9498
9499     if (oldGameMode == AnalyzeFile ||
9500         oldGameMode == AnalyzeMode) {
9501       AnalyzeFileEvent();
9502     }
9503
9504     if (matchMode || appData.timeDelay == 0) {
9505       ToEndEvent();
9506       gameMode = EditGame;
9507       ModeHighlight();
9508     } else if (appData.timeDelay > 0) {
9509       AutoPlayGameLoop();
9510     }
9511
9512     if (appData.debugMode)
9513         fprintf(debugFP, "LoadGame(): on exit, gameMode %d\n", gameMode);
9514
9515     loadFlag = 0; /* [HGM] true game starts */
9516     return TRUE;
9517 }
9518
9519 /* Support for LoadNextPosition, LoadPreviousPosition, ReloadSamePosition */
9520 int
9521 ReloadPosition(offset)
9522      int offset;
9523 {
9524     int positionNumber = lastLoadPositionNumber + offset;
9525     if (lastLoadPositionFP == NULL) {
9526         DisplayError(_("No position has been loaded yet"), 0);
9527         return FALSE;
9528     }
9529     if (positionNumber <= 0) {
9530         DisplayError(_("Can't back up any further"), 0);
9531         return FALSE;
9532     }
9533     return LoadPosition(lastLoadPositionFP, positionNumber,
9534                         lastLoadPositionTitle);
9535 }
9536
9537 /* Load the nth position from the given file */
9538 int
9539 LoadPositionFromFile(filename, n, title)
9540      char *filename;
9541      int n;
9542      char *title;
9543 {
9544     FILE *f;
9545     char buf[MSG_SIZ];
9546
9547     if (strcmp(filename, "-") == 0) {
9548         return LoadPosition(stdin, n, "stdin");
9549     } else {
9550         f = fopen(filename, "rb");
9551         if (f == NULL) {
9552             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
9553             DisplayError(buf, errno);
9554             return FALSE;
9555         } else {
9556             return LoadPosition(f, n, title);
9557         }
9558     }
9559 }
9560
9561 /* Load the nth position from the given open file, and close it */
9562 int
9563 LoadPosition(f, positionNumber, title)
9564      FILE *f;
9565      int positionNumber;
9566      char *title;
9567 {
9568     char *p, line[MSG_SIZ];
9569     Board initial_position;
9570     int i, j, fenMode, pn;
9571
9572     if (gameMode == Training )
9573         SetTrainingModeOff();
9574
9575     if (gameMode != BeginningOfGame) {
9576         Reset(FALSE, TRUE);
9577     }
9578     if (lastLoadPositionFP != NULL && lastLoadPositionFP != f) {
9579         fclose(lastLoadPositionFP);
9580     }
9581     if (positionNumber == 0) positionNumber = 1;
9582     lastLoadPositionFP = f;
9583     lastLoadPositionNumber = positionNumber;
9584     strcpy(lastLoadPositionTitle, title);
9585     if (first.pr == NoProc) {
9586       StartChessProgram(&first);
9587       InitChessProgram(&first, FALSE);
9588     }
9589     pn = positionNumber;
9590     if (positionNumber < 0) {
9591         /* Negative position number means to seek to that byte offset */
9592         if (fseek(f, -positionNumber, 0) == -1) {
9593             DisplayError(_("Can't seek on position file"), 0);
9594             return FALSE;
9595         };
9596         pn = 1;
9597     } else {
9598         if (fseek(f, 0, 0) == -1) {
9599             if (f == lastLoadPositionFP ?
9600                 positionNumber == lastLoadPositionNumber + 1 :
9601                 positionNumber == 1) {
9602                 pn = 1;
9603             } else {
9604                 DisplayError(_("Can't seek on position file"), 0);
9605                 return FALSE;
9606             }
9607         }
9608     }
9609     /* See if this file is FEN or old-style xboard */
9610     if (fgets(line, MSG_SIZ, f) == NULL) {
9611         DisplayError(_("Position not found in file"), 0);
9612         return FALSE;
9613     }
9614     // [HGM] FEN can begin with digit, any piece letter valid in this variant, or a + for Shogi promoted pieces
9615     fenMode = line[0] >= '0' && line[0] <= '9' || line[0] == '+' || CharToPiece(line[0]) != EmptySquare;
9616
9617     if (pn >= 2) {
9618         if (fenMode || line[0] == '#') pn--;
9619         while (pn > 0) {
9620             /* skip positions before number pn */
9621             if (fgets(line, MSG_SIZ, f) == NULL) {
9622                 Reset(TRUE, TRUE);
9623                 DisplayError(_("Position not found in file"), 0);
9624                 return FALSE;
9625             }
9626             if (fenMode || line[0] == '#') pn--;
9627         }
9628     }
9629
9630     if (fenMode) {
9631         if (!ParseFEN(initial_position, &blackPlaysFirst, line)) {
9632             DisplayError(_("Bad FEN position in file"), 0);
9633             return FALSE;
9634         }
9635     } else {
9636         (void) fgets(line, MSG_SIZ, f);
9637         (void) fgets(line, MSG_SIZ, f);
9638
9639         for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
9640             (void) fgets(line, MSG_SIZ, f);
9641             for (p = line, j = BOARD_LEFT; j < BOARD_RGHT; p++) {
9642                 if (*p == ' ')
9643                   continue;
9644                 initial_position[i][j++] = CharToPiece(*p);
9645             }
9646         }
9647
9648         blackPlaysFirst = FALSE;
9649         if (!feof(f)) {
9650             (void) fgets(line, MSG_SIZ, f);
9651             if (strncmp(line, "black", strlen("black"))==0)
9652               blackPlaysFirst = TRUE;
9653         }
9654     }
9655     startedFromSetupPosition = TRUE;
9656
9657     SendToProgram("force\n", &first);
9658     CopyBoard(boards[0], initial_position);
9659     if (blackPlaysFirst) {
9660         currentMove = forwardMostMove = backwardMostMove = 1;
9661         strcpy(moveList[0], "");
9662         strcpy(parseList[0], "");
9663         CopyBoard(boards[1], initial_position);
9664         DisplayMessage("", _("Black to play"));
9665     } else {
9666         currentMove = forwardMostMove = backwardMostMove = 0;
9667         DisplayMessage("", _("White to play"));
9668     }
9669           /* [HGM] copy FEN attributes as well */
9670           {   int i;
9671               initialRulePlies = FENrulePlies;
9672               epStatus[forwardMostMove] = FENepStatus;
9673               for( i=0; i< nrCastlingRights; i++ )
9674                   castlingRights[forwardMostMove][i] = FENcastlingRights[i];
9675           }
9676     SendBoard(&first, forwardMostMove);
9677     if (appData.debugMode) {
9678 int i, j;
9679   for(i=0;i<2;i++){for(j=0;j<6;j++)fprintf(debugFP, " %d", castlingRights[i][j]);fprintf(debugFP,"\n");}
9680   for(j=0;j<6;j++)fprintf(debugFP, " %d", initialRights[j]);fprintf(debugFP,"\n");
9681         fprintf(debugFP, "Load Position\n");
9682     }
9683
9684     if (positionNumber > 1) {
9685         sprintf(line, "%s %d", title, positionNumber);
9686         DisplayTitle(line);
9687     } else {
9688         DisplayTitle(title);
9689     }
9690     gameMode = EditGame;
9691     ModeHighlight();
9692     ResetClocks();
9693     timeRemaining[0][1] = whiteTimeRemaining;
9694     timeRemaining[1][1] = blackTimeRemaining;
9695     DrawPosition(FALSE, boards[currentMove]);
9696
9697     return TRUE;
9698 }
9699
9700
9701 void
9702 CopyPlayerNameIntoFileName(dest, src)
9703      char **dest, *src;
9704 {
9705     while (*src != NULLCHAR && *src != ',') {
9706         if (*src == ' ') {
9707             *(*dest)++ = '_';
9708             src++;
9709         } else {
9710             *(*dest)++ = *src++;
9711         }
9712     }
9713 }
9714
9715 char *DefaultFileName(ext)
9716      char *ext;
9717 {
9718     static char def[MSG_SIZ];
9719     char *p;
9720
9721     if (gameInfo.white != NULL && gameInfo.white[0] != '-') {
9722         p = def;
9723         CopyPlayerNameIntoFileName(&p, gameInfo.white);
9724         *p++ = '-';
9725         CopyPlayerNameIntoFileName(&p, gameInfo.black);
9726         *p++ = '.';
9727         strcpy(p, ext);
9728     } else {
9729         def[0] = NULLCHAR;
9730     }
9731     return def;
9732 }
9733
9734 /* Save the current game to the given file */
9735 int
9736 SaveGameToFile(filename, append)
9737      char *filename;
9738      int append;
9739 {
9740     FILE *f;
9741     char buf[MSG_SIZ];
9742
9743     if (strcmp(filename, "-") == 0) {
9744         return SaveGame(stdout, 0, NULL);
9745     } else {
9746         f = fopen(filename, append ? "a" : "w");
9747         if (f == NULL) {
9748             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
9749             DisplayError(buf, errno);
9750             return FALSE;
9751         } else {
9752             return SaveGame(f, 0, NULL);
9753         }
9754     }
9755 }
9756
9757 char *
9758 SavePart(str)
9759      char *str;
9760 {
9761     static char buf[MSG_SIZ];
9762     char *p;
9763
9764     p = strchr(str, ' ');
9765     if (p == NULL) return str;
9766     strncpy(buf, str, p - str);
9767     buf[p - str] = NULLCHAR;
9768     return buf;
9769 }
9770
9771 #define PGN_MAX_LINE 75
9772
9773 #define PGN_SIDE_WHITE  0
9774 #define PGN_SIDE_BLACK  1
9775
9776 /* [AS] */
9777 static int FindFirstMoveOutOfBook( int side )
9778 {
9779     int result = -1;
9780
9781     if( backwardMostMove == 0 && ! startedFromSetupPosition) {
9782         int index = backwardMostMove;
9783         int has_book_hit = 0;
9784
9785         if( (index % 2) != side ) {
9786             index++;
9787         }
9788
9789         while( index < forwardMostMove ) {
9790             /* Check to see if engine is in book */
9791             int depth = pvInfoList[index].depth;
9792             int score = pvInfoList[index].score;
9793             int in_book = 0;
9794
9795             if( depth <= 2 ) {
9796                 in_book = 1;
9797             }
9798             else if( score == 0 && depth == 63 ) {
9799                 in_book = 1; /* Zappa */
9800             }
9801             else if( score == 2 && depth == 99 ) {
9802                 in_book = 1; /* Abrok */
9803             }
9804
9805             has_book_hit += in_book;
9806
9807             if( ! in_book ) {
9808                 result = index;
9809
9810                 break;
9811             }
9812
9813             index += 2;
9814         }
9815     }
9816
9817     return result;
9818 }
9819
9820 /* [AS] */
9821 void GetOutOfBookInfo( char * buf )
9822 {
9823     int oob[2];
9824     int i;
9825     int offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
9826
9827     oob[0] = FindFirstMoveOutOfBook( PGN_SIDE_WHITE );
9828     oob[1] = FindFirstMoveOutOfBook( PGN_SIDE_BLACK );
9829
9830     *buf = '\0';
9831
9832     if( oob[0] >= 0 || oob[1] >= 0 ) {
9833         for( i=0; i<2; i++ ) {
9834             int idx = oob[i];
9835
9836             if( idx >= 0 ) {
9837                 if( i > 0 && oob[0] >= 0 ) {
9838                     strcat( buf, "   " );
9839                 }
9840
9841                 sprintf( buf+strlen(buf), "%d%s. ", (idx - offset)/2 + 1, idx & 1 ? ".." : "" );
9842                 sprintf( buf+strlen(buf), "%s%.2f",
9843                     pvInfoList[idx].score >= 0 ? "+" : "",
9844                     pvInfoList[idx].score / 100.0 );
9845             }
9846         }
9847     }
9848 }
9849
9850 /* Save game in PGN style and close the file */
9851 int
9852 SaveGamePGN(f)
9853      FILE *f;
9854 {
9855     int i, offset, linelen, newblock;
9856     time_t tm;
9857 //    char *movetext;
9858     char numtext[32];
9859     int movelen, numlen, blank;
9860     char move_buffer[100]; /* [AS] Buffer for move+PV info */
9861
9862     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
9863
9864     tm = time((time_t *) NULL);
9865
9866     PrintPGNTags(f, &gameInfo);
9867
9868     if (backwardMostMove > 0 || startedFromSetupPosition) {
9869         char *fen = PositionToFEN(backwardMostMove, NULL);
9870         fprintf(f, "[FEN \"%s\"]\n[SetUp \"1\"]\n", fen);
9871         fprintf(f, "\n{--------------\n");
9872         PrintPosition(f, backwardMostMove);
9873         fprintf(f, "--------------}\n");
9874         free(fen);
9875     }
9876     else {
9877         /* [AS] Out of book annotation */
9878         if( appData.saveOutOfBookInfo ) {
9879             char buf[64];
9880
9881             GetOutOfBookInfo( buf );
9882
9883             if( buf[0] != '\0' ) {
9884                 fprintf( f, "[%s \"%s\"]\n", PGN_OUT_OF_BOOK, buf );
9885             }
9886         }
9887
9888         fprintf(f, "\n");
9889     }
9890
9891     i = backwardMostMove;
9892     linelen = 0;
9893     newblock = TRUE;
9894
9895     while (i < forwardMostMove) {
9896         /* Print comments preceding this move */
9897         if (commentList[i] != NULL) {
9898             if (linelen > 0) fprintf(f, "\n");
9899             fprintf(f, "{\n%s}\n", commentList[i]);
9900             linelen = 0;
9901             newblock = TRUE;
9902         }
9903
9904         /* Format move number */
9905         if ((i % 2) == 0) {
9906             sprintf(numtext, "%d.", (i - offset)/2 + 1);
9907         } else {
9908             if (newblock) {
9909                 sprintf(numtext, "%d...", (i - offset)/2 + 1);
9910             } else {
9911                 numtext[0] = NULLCHAR;
9912             }
9913         }
9914         numlen = strlen(numtext);
9915         newblock = FALSE;
9916
9917         /* Print move number */
9918         blank = linelen > 0 && numlen > 0;
9919         if (linelen + (blank ? 1 : 0) + numlen > PGN_MAX_LINE) {
9920             fprintf(f, "\n");
9921             linelen = 0;
9922             blank = 0;
9923         }
9924         if (blank) {
9925             fprintf(f, " ");
9926             linelen++;
9927         }
9928         fprintf(f, "%s", numtext);
9929         linelen += numlen;
9930
9931         /* Get move */
9932         strcpy(move_buffer, SavePart(parseList[i])); // [HGM] pgn: print move via buffer, so it can be edited
9933         movelen = strlen(move_buffer); /* [HGM] pgn: line-break point before move */
9934
9935         /* Print move */
9936         blank = linelen > 0 && movelen > 0;
9937         if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
9938             fprintf(f, "\n");
9939             linelen = 0;
9940             blank = 0;
9941         }
9942         if (blank) {
9943             fprintf(f, " ");
9944             linelen++;
9945         }
9946         fprintf(f, "%s", move_buffer);
9947         linelen += movelen;
9948
9949         /* [AS] Add PV info if present */
9950         if( i >= 0 && appData.saveExtendedInfoInPGN && pvInfoList[i].depth > 0 ) {
9951             /* [HGM] add time */
9952             char buf[MSG_SIZ]; int seconds;
9953
9954             seconds = (pvInfoList[i].time+5)/10; // deci-seconds, rounded to nearest
9955
9956             if( seconds <= 0) buf[0] = 0; else
9957             if( seconds < 30 ) sprintf(buf, " %3.1f%c", seconds/10., 0); else {
9958                 seconds = (seconds + 4)/10; // round to full seconds
9959                 if( seconds < 60 ) sprintf(buf, " %d%c", seconds, 0); else
9960                                    sprintf(buf, " %d:%02d%c", seconds/60, seconds%60, 0);
9961             }
9962
9963             sprintf( move_buffer, "{%s%.2f/%d%s}",
9964                 pvInfoList[i].score >= 0 ? "+" : "",
9965                 pvInfoList[i].score / 100.0,
9966                 pvInfoList[i].depth,
9967                 buf );
9968
9969             movelen = strlen(move_buffer); /* [HGM] pgn: line-break point after move */
9970
9971             /* Print score/depth */
9972             blank = linelen > 0 && movelen > 0;
9973             if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
9974                 fprintf(f, "\n");
9975                 linelen = 0;
9976                 blank = 0;
9977             }
9978             if (blank) {
9979                 fprintf(f, " ");
9980                 linelen++;
9981             }
9982             fprintf(f, "%s", move_buffer);
9983             linelen += movelen;
9984         }
9985
9986         i++;
9987     }
9988
9989     /* Start a new line */
9990     if (linelen > 0) fprintf(f, "\n");
9991
9992     /* Print comments after last move */
9993     if (commentList[i] != NULL) {
9994         fprintf(f, "{\n%s}\n", commentList[i]);
9995     }
9996
9997     /* Print result */
9998     if (gameInfo.resultDetails != NULL &&
9999         gameInfo.resultDetails[0] != NULLCHAR) {
10000         fprintf(f, "{%s} %s\n\n", gameInfo.resultDetails,
10001                 PGNResult(gameInfo.result));
10002     } else {
10003         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
10004     }
10005
10006     fclose(f);
10007     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
10008     return TRUE;
10009 }
10010
10011 /* Save game in old style and close the file */
10012 int
10013 SaveGameOldStyle(f)
10014      FILE *f;
10015 {
10016     int i, offset;
10017     time_t tm;
10018
10019     tm = time((time_t *) NULL);
10020
10021     fprintf(f, "# %s game file -- %s", programName, ctime(&tm));
10022     PrintOpponents(f);
10023
10024     if (backwardMostMove > 0 || startedFromSetupPosition) {
10025         fprintf(f, "\n[--------------\n");
10026         PrintPosition(f, backwardMostMove);
10027         fprintf(f, "--------------]\n");
10028     } else {
10029         fprintf(f, "\n");
10030     }
10031
10032     i = backwardMostMove;
10033     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
10034
10035     while (i < forwardMostMove) {
10036         if (commentList[i] != NULL) {
10037             fprintf(f, "[%s]\n", commentList[i]);
10038         }
10039
10040         if ((i % 2) == 1) {
10041             fprintf(f, "%d. ...  %s\n", (i - offset)/2 + 1, parseList[i]);
10042             i++;
10043         } else {
10044             fprintf(f, "%d. %s  ", (i - offset)/2 + 1, parseList[i]);
10045             i++;
10046             if (commentList[i] != NULL) {
10047                 fprintf(f, "\n");
10048                 continue;
10049             }
10050             if (i >= forwardMostMove) {
10051                 fprintf(f, "\n");
10052                 break;
10053             }
10054             fprintf(f, "%s\n", parseList[i]);
10055             i++;
10056         }
10057     }
10058
10059     if (commentList[i] != NULL) {
10060         fprintf(f, "[%s]\n", commentList[i]);
10061     }
10062
10063     /* This isn't really the old style, but it's close enough */
10064     if (gameInfo.resultDetails != NULL &&
10065         gameInfo.resultDetails[0] != NULLCHAR) {
10066         fprintf(f, "%s (%s)\n\n", PGNResult(gameInfo.result),
10067                 gameInfo.resultDetails);
10068     } else {
10069         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
10070     }
10071
10072     fclose(f);
10073     return TRUE;
10074 }
10075
10076 /* Save the current game to open file f and close the file */
10077 int
10078 SaveGame(f, dummy, dummy2)
10079      FILE *f;
10080      int dummy;
10081      char *dummy2;
10082 {
10083     if (gameMode == EditPosition) EditPositionDone(TRUE);
10084     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
10085     if (appData.oldSaveStyle)
10086       return SaveGameOldStyle(f);
10087     else
10088       return SaveGamePGN(f);
10089 }
10090
10091 /* Save the current position to the given file */
10092 int
10093 SavePositionToFile(filename)
10094      char *filename;
10095 {
10096     FILE *f;
10097     char buf[MSG_SIZ];
10098
10099     if (strcmp(filename, "-") == 0) {
10100         return SavePosition(stdout, 0, NULL);
10101     } else {
10102         f = fopen(filename, "a");
10103         if (f == NULL) {
10104             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
10105             DisplayError(buf, errno);
10106             return FALSE;
10107         } else {
10108             SavePosition(f, 0, NULL);
10109             return TRUE;
10110         }
10111     }
10112 }
10113
10114 /* Save the current position to the given open file and close the file */
10115 int
10116 SavePosition(f, dummy, dummy2)
10117      FILE *f;
10118      int dummy;
10119      char *dummy2;
10120 {
10121     time_t tm;
10122     char *fen;
10123
10124     if (gameMode == EditPosition) EditPositionDone(TRUE);
10125     if (appData.oldSaveStyle) {
10126         tm = time((time_t *) NULL);
10127
10128         fprintf(f, "# %s position file -- %s", programName, ctime(&tm));
10129         PrintOpponents(f);
10130         fprintf(f, "[--------------\n");
10131         PrintPosition(f, currentMove);
10132         fprintf(f, "--------------]\n");
10133     } else {
10134         fen = PositionToFEN(currentMove, NULL);
10135         fprintf(f, "%s\n", fen);
10136         free(fen);
10137     }
10138     fclose(f);
10139     return TRUE;
10140 }
10141
10142 void
10143 ReloadCmailMsgEvent(unregister)
10144      int unregister;
10145 {
10146 #if !WIN32
10147     static char *inFilename = NULL;
10148     static char *outFilename;
10149     int i;
10150     struct stat inbuf, outbuf;
10151     int status;
10152
10153     /* Any registered moves are unregistered if unregister is set, */
10154     /* i.e. invoked by the signal handler */
10155     if (unregister) {
10156         for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
10157             cmailMoveRegistered[i] = FALSE;
10158             if (cmailCommentList[i] != NULL) {
10159                 free(cmailCommentList[i]);
10160                 cmailCommentList[i] = NULL;
10161             }
10162         }
10163         nCmailMovesRegistered = 0;
10164     }
10165
10166     for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
10167         cmailResult[i] = CMAIL_NOT_RESULT;
10168     }
10169     nCmailResults = 0;
10170
10171     if (inFilename == NULL) {
10172         /* Because the filenames are static they only get malloced once  */
10173         /* and they never get freed                                      */
10174         inFilename = (char *) malloc(strlen(appData.cmailGameName) + 9);
10175         sprintf(inFilename, "%s.game.in", appData.cmailGameName);
10176
10177         outFilename = (char *) malloc(strlen(appData.cmailGameName) + 5);
10178         sprintf(outFilename, "%s.out", appData.cmailGameName);
10179     }
10180
10181     status = stat(outFilename, &outbuf);
10182     if (status < 0) {
10183         cmailMailedMove = FALSE;
10184     } else {
10185         status = stat(inFilename, &inbuf);
10186         cmailMailedMove = (inbuf.st_mtime < outbuf.st_mtime);
10187     }
10188
10189     /* LoadGameFromFile(CMAIL_MAX_GAMES) with cmailMsgLoaded == TRUE
10190        counts the games, notes how each one terminated, etc.
10191
10192        It would be nice to remove this kludge and instead gather all
10193        the information while building the game list.  (And to keep it
10194        in the game list nodes instead of having a bunch of fixed-size
10195        parallel arrays.)  Note this will require getting each game's
10196        termination from the PGN tags, as the game list builder does
10197        not process the game moves.  --mann
10198        */
10199     cmailMsgLoaded = TRUE;
10200     LoadGameFromFile(inFilename, CMAIL_MAX_GAMES, "", FALSE);
10201
10202     /* Load first game in the file or popup game menu */
10203     LoadGameFromFile(inFilename, 0, appData.cmailGameName, TRUE);
10204
10205 #endif /* !WIN32 */
10206     return;
10207 }
10208
10209 int
10210 RegisterMove()
10211 {
10212     FILE *f;
10213     char string[MSG_SIZ];
10214
10215     if (   cmailMailedMove
10216         || (cmailResult[lastLoadGameNumber - 1] == CMAIL_OLD_RESULT)) {
10217         return TRUE;            /* Allow free viewing  */
10218     }
10219
10220     /* Unregister move to ensure that we don't leave RegisterMove        */
10221     /* with the move registered when the conditions for registering no   */
10222     /* longer hold                                                       */
10223     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
10224         cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
10225         nCmailMovesRegistered --;
10226
10227         if (cmailCommentList[lastLoadGameNumber - 1] != NULL)
10228           {
10229               free(cmailCommentList[lastLoadGameNumber - 1]);
10230               cmailCommentList[lastLoadGameNumber - 1] = NULL;
10231           }
10232     }
10233
10234     if (cmailOldMove == -1) {
10235         DisplayError(_("You have edited the game history.\nUse Reload Same Game and make your move again."), 0);
10236         return FALSE;
10237     }
10238
10239     if (currentMove > cmailOldMove + 1) {
10240         DisplayError(_("You have entered too many moves.\nBack up to the correct position and try again."), 0);
10241         return FALSE;
10242     }
10243
10244     if (currentMove < cmailOldMove) {
10245         DisplayError(_("Displayed position is not current.\nStep forward to the correct position and try again."), 0);
10246         return FALSE;
10247     }
10248
10249     if (forwardMostMove > currentMove) {
10250         /* Silently truncate extra moves */
10251         TruncateGame();
10252     }
10253
10254     if (   (currentMove == cmailOldMove + 1)
10255         || (   (currentMove == cmailOldMove)
10256             && (   (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_ACCEPT)
10257                 || (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_RESIGN)))) {
10258         if (gameInfo.result != GameUnfinished) {
10259             cmailResult[lastLoadGameNumber - 1] = CMAIL_NEW_RESULT;
10260         }
10261
10262         if (commentList[currentMove] != NULL) {
10263             cmailCommentList[lastLoadGameNumber - 1]
10264               = StrSave(commentList[currentMove]);
10265         }
10266         strcpy(cmailMove[lastLoadGameNumber - 1], moveList[currentMove - 1]);
10267
10268         if (appData.debugMode)
10269           fprintf(debugFP, "Saving %s for game %d\n",
10270                   cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
10271
10272         sprintf(string,
10273                 "%s.game.out.%d", appData.cmailGameName, lastLoadGameNumber);
10274
10275         f = fopen(string, "w");
10276         if (appData.oldSaveStyle) {
10277             SaveGameOldStyle(f); /* also closes the file */
10278
10279             sprintf(string, "%s.pos.out", appData.cmailGameName);
10280             f = fopen(string, "w");
10281             SavePosition(f, 0, NULL); /* also closes the file */
10282         } else {
10283             fprintf(f, "{--------------\n");
10284             PrintPosition(f, currentMove);
10285             fprintf(f, "--------------}\n\n");
10286
10287             SaveGame(f, 0, NULL); /* also closes the file*/
10288         }
10289
10290         cmailMoveRegistered[lastLoadGameNumber - 1] = TRUE;
10291         nCmailMovesRegistered ++;
10292     } else if (nCmailGames == 1) {
10293         DisplayError(_("You have not made a move yet"), 0);
10294         return FALSE;
10295     }
10296
10297     return TRUE;
10298 }
10299
10300 void
10301 MailMoveEvent()
10302 {
10303 #if !WIN32
10304     static char *partCommandString = "cmail -xv%s -remail -game %s 2>&1";
10305     FILE *commandOutput;
10306     char buffer[MSG_SIZ], msg[MSG_SIZ], string[MSG_SIZ];
10307     int nBytes = 0;             /*  Suppress warnings on uninitialized variables    */
10308     int nBuffers;
10309     int i;
10310     int archived;
10311     char *arcDir;
10312
10313     if (! cmailMsgLoaded) {
10314         DisplayError(_("The cmail message is not loaded.\nUse Reload CMail Message and make your move again."), 0);
10315         return;
10316     }
10317
10318     if (nCmailGames == nCmailResults) {
10319         DisplayError(_("No unfinished games"), 0);
10320         return;
10321     }
10322
10323 #if CMAIL_PROHIBIT_REMAIL
10324     if (cmailMailedMove) {
10325         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);
10326         DisplayError(msg, 0);
10327         return;
10328     }
10329 #endif
10330
10331     if (! (cmailMailedMove || RegisterMove())) return;
10332
10333     if (   cmailMailedMove
10334         || (nCmailMovesRegistered + nCmailResults == nCmailGames)) {
10335         sprintf(string, partCommandString,
10336                 appData.debugMode ? " -v" : "", appData.cmailGameName);
10337         commandOutput = popen(string, "r");
10338
10339         if (commandOutput == NULL) {
10340             DisplayError(_("Failed to invoke cmail"), 0);
10341         } else {
10342             for (nBuffers = 0; (! feof(commandOutput)); nBuffers ++) {
10343                 nBytes = fread(buffer, 1, MSG_SIZ - 1, commandOutput);
10344             }
10345             if (nBuffers > 1) {
10346                 (void) memcpy(msg, buffer + nBytes, MSG_SIZ - nBytes - 1);
10347                 (void) memcpy(msg + MSG_SIZ - nBytes - 1, buffer, nBytes);
10348                 nBytes = MSG_SIZ - 1;
10349             } else {
10350                 (void) memcpy(msg, buffer, nBytes);
10351             }
10352             *(msg + nBytes) = '\0'; /* \0 for end-of-string*/
10353
10354             if(StrStr(msg, "Mailed cmail message to ") != NULL) {
10355                 cmailMailedMove = TRUE; /* Prevent >1 moves    */
10356
10357                 archived = TRUE;
10358                 for (i = 0; i < nCmailGames; i ++) {
10359                     if (cmailResult[i] == CMAIL_NOT_RESULT) {
10360                         archived = FALSE;
10361                     }
10362                 }
10363                 if (   archived
10364                     && (   (arcDir = (char *) getenv("CMAIL_ARCDIR"))
10365                         != NULL)) {
10366                     sprintf(buffer, "%s/%s.%s.archive",
10367                             arcDir,
10368                             appData.cmailGameName,
10369                             gameInfo.date);
10370                     LoadGameFromFile(buffer, 1, buffer, FALSE);
10371                     cmailMsgLoaded = FALSE;
10372                 }
10373             }
10374
10375             DisplayInformation(msg);
10376             pclose(commandOutput);
10377         }
10378     } else {
10379         if ((*cmailMsg) != '\0') {
10380             DisplayInformation(cmailMsg);
10381         }
10382     }
10383
10384     return;
10385 #endif /* !WIN32 */
10386 }
10387
10388 char *
10389 CmailMsg()
10390 {
10391 #if WIN32
10392     return NULL;
10393 #else
10394     int  prependComma = 0;
10395     char number[5];
10396     char string[MSG_SIZ];       /* Space for game-list */
10397     int  i;
10398
10399     if (!cmailMsgLoaded) return "";
10400
10401     if (cmailMailedMove) {
10402         sprintf(cmailMsg, _("Waiting for reply from opponent\n"));
10403     } else {
10404         /* Create a list of games left */
10405         sprintf(string, "[");
10406         for (i = 0; i < nCmailGames; i ++) {
10407             if (! (   cmailMoveRegistered[i]
10408                    || (cmailResult[i] == CMAIL_OLD_RESULT))) {
10409                 if (prependComma) {
10410                     sprintf(number, ",%d", i + 1);
10411                 } else {
10412                     sprintf(number, "%d", i + 1);
10413                     prependComma = 1;
10414                 }
10415
10416                 strcat(string, number);
10417             }
10418         }
10419         strcat(string, "]");
10420
10421         if (nCmailMovesRegistered + nCmailResults == 0) {
10422             switch (nCmailGames) {
10423               case 1:
10424                 sprintf(cmailMsg,
10425                         _("Still need to make move for game\n"));
10426                 break;
10427
10428               case 2:
10429                 sprintf(cmailMsg,
10430                         _("Still need to make moves for both games\n"));
10431                 break;
10432
10433               default:
10434                 sprintf(cmailMsg,
10435                         _("Still need to make moves for all %d games\n"),
10436                         nCmailGames);
10437                 break;
10438             }
10439         } else {
10440             switch (nCmailGames - nCmailMovesRegistered - nCmailResults) {
10441               case 1:
10442                 sprintf(cmailMsg,
10443                         _("Still need to make a move for game %s\n"),
10444                         string);
10445                 break;
10446
10447               case 0:
10448                 if (nCmailResults == nCmailGames) {
10449                     sprintf(cmailMsg, _("No unfinished games\n"));
10450                 } else {
10451                     sprintf(cmailMsg, _("Ready to send mail\n"));
10452                 }
10453                 break;
10454
10455               default:
10456                 sprintf(cmailMsg,
10457                         _("Still need to make moves for games %s\n"),
10458                         string);
10459             }
10460         }
10461     }
10462     return cmailMsg;
10463 #endif /* WIN32 */
10464 }
10465
10466 void
10467 ResetGameEvent()
10468 {
10469     if (gameMode == Training)
10470       SetTrainingModeOff();
10471
10472     Reset(TRUE, TRUE);
10473     cmailMsgLoaded = FALSE;
10474     if (appData.icsActive) {
10475       SendToICS(ics_prefix);
10476       SendToICS("refresh\n");
10477     }
10478 }
10479
10480 void
10481 ExitEvent(status)
10482      int status;
10483 {
10484     exiting++;
10485     if (exiting > 2) {
10486       /* Give up on clean exit */
10487       exit(status);
10488     }
10489     if (exiting > 1) {
10490       /* Keep trying for clean exit */
10491       return;
10492     }
10493
10494     if (appData.icsActive && appData.colorize) Colorize(ColorNone, FALSE);
10495
10496     if (telnetISR != NULL) {
10497       RemoveInputSource(telnetISR);
10498     }
10499     if (icsPR != NoProc) {
10500       DestroyChildProcess(icsPR, TRUE);
10501     }
10502
10503     /* [HGM] crash: leave writing PGN and position entirely to GameEnds() */
10504     GameEnds(gameInfo.result, gameInfo.resultDetails==NULL ? "xboard exit" : gameInfo.resultDetails, GE_PLAYER);
10505
10506     /* [HGM] crash: the above GameEnds() is a dud if another one was running */
10507     /* make sure this other one finishes before killing it!                  */
10508     if(endingGame) { int count = 0;
10509         if(appData.debugMode) fprintf(debugFP, "ExitEvent() during GameEnds(), wait\n");
10510         while(endingGame && count++ < 10) DoSleep(1);
10511         if(appData.debugMode && endingGame) fprintf(debugFP, "GameEnds() seems stuck, proceed exiting\n");
10512     }
10513
10514     /* Kill off chess programs */
10515     if (first.pr != NoProc) {
10516         ExitAnalyzeMode();
10517
10518         DoSleep( appData.delayBeforeQuit );
10519         SendToProgram("quit\n", &first);
10520         DoSleep( appData.delayAfterQuit );
10521         DestroyChildProcess(first.pr, 10 /* [AS] first.useSigterm */ );
10522     }
10523     if (second.pr != NoProc) {
10524         DoSleep( appData.delayBeforeQuit );
10525         SendToProgram("quit\n", &second);
10526         DoSleep( appData.delayAfterQuit );
10527         DestroyChildProcess(second.pr, 10 /* [AS] second.useSigterm */ );
10528     }
10529     if (first.isr != NULL) {
10530         RemoveInputSource(first.isr);
10531     }
10532     if (second.isr != NULL) {
10533         RemoveInputSource(second.isr);
10534     }
10535
10536     ShutDownFrontEnd();
10537     exit(status);
10538 }
10539
10540 void
10541 PauseEvent()
10542 {
10543     if (appData.debugMode)
10544         fprintf(debugFP, "PauseEvent(): pausing %d\n", pausing);
10545     if (pausing) {
10546         pausing = FALSE;
10547         ModeHighlight();
10548         if (gameMode == MachinePlaysWhite ||
10549             gameMode == MachinePlaysBlack) {
10550             StartClocks();
10551         } else {
10552             DisplayBothClocks();
10553         }
10554         if (gameMode == PlayFromGameFile) {
10555             if (appData.timeDelay >= 0)
10556                 AutoPlayGameLoop();
10557         } else if (gameMode == IcsExamining && pauseExamInvalid) {
10558             Reset(FALSE, TRUE);
10559             SendToICS(ics_prefix);
10560             SendToICS("refresh\n");
10561         } else if (currentMove < forwardMostMove) {
10562             ForwardInner(forwardMostMove);
10563         }
10564         pauseExamInvalid = FALSE;
10565     } else {
10566         switch (gameMode) {
10567           default:
10568             return;
10569           case IcsExamining:
10570             pauseExamForwardMostMove = forwardMostMove;
10571             pauseExamInvalid = FALSE;
10572             /* fall through */
10573           case IcsObserving:
10574           case IcsPlayingWhite:
10575           case IcsPlayingBlack:
10576             pausing = TRUE;
10577             ModeHighlight();
10578             return;
10579           case PlayFromGameFile:
10580             (void) StopLoadGameTimer();
10581             pausing = TRUE;
10582             ModeHighlight();
10583             break;
10584           case BeginningOfGame:
10585             if (appData.icsActive) return;
10586             /* else fall through */
10587           case MachinePlaysWhite:
10588           case MachinePlaysBlack:
10589           case TwoMachinesPlay:
10590             if (forwardMostMove == 0)
10591               return;           /* don't pause if no one has moved */
10592             if ((gameMode == MachinePlaysWhite &&
10593                  !WhiteOnMove(forwardMostMove)) ||
10594                 (gameMode == MachinePlaysBlack &&
10595                  WhiteOnMove(forwardMostMove))) {
10596                 StopClocks();
10597             }
10598             pausing = TRUE;
10599             ModeHighlight();
10600             break;
10601         }
10602     }
10603 }
10604
10605 void
10606 EditCommentEvent()
10607 {
10608     char title[MSG_SIZ];
10609
10610     if (currentMove < 1 || parseList[currentMove - 1][0] == NULLCHAR) {
10611         strcpy(title, _("Edit comment"));
10612     } else {
10613         sprintf(title, _("Edit comment on %d.%s%s"), (currentMove - 1) / 2 + 1,
10614                 WhiteOnMove(currentMove - 1) ? " " : ".. ",
10615                 parseList[currentMove - 1]);
10616     }
10617
10618     EditCommentPopUp(currentMove, title, commentList[currentMove]);
10619 }
10620
10621
10622 void
10623 EditTagsEvent()
10624 {
10625     char *tags = PGNTags(&gameInfo);
10626     EditTagsPopUp(tags);
10627     free(tags);
10628 }
10629
10630 void
10631 AnalyzeModeEvent()
10632 {
10633     if (appData.noChessProgram || gameMode == AnalyzeMode)
10634       return;
10635
10636     if (gameMode != AnalyzeFile) {
10637         if (!appData.icsEngineAnalyze) {
10638                EditGameEvent();
10639                if (gameMode != EditGame) return;
10640         }
10641         ResurrectChessProgram();
10642         SendToProgram("analyze\n", &first);
10643         first.analyzing = TRUE;
10644         /*first.maybeThinking = TRUE;*/
10645         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
10646         EngineOutputPopUp();
10647     }
10648     if (!appData.icsEngineAnalyze) gameMode = AnalyzeMode;
10649     pausing = FALSE;
10650     ModeHighlight();
10651     SetGameInfo();
10652
10653     StartAnalysisClock();
10654     GetTimeMark(&lastNodeCountTime);
10655     lastNodeCount = 0;
10656 }
10657
10658 void
10659 AnalyzeFileEvent()
10660 {
10661     if (appData.noChessProgram || gameMode == AnalyzeFile)
10662       return;
10663
10664     if (gameMode != AnalyzeMode) {
10665         EditGameEvent();
10666         if (gameMode != EditGame) return;
10667         ResurrectChessProgram();
10668         SendToProgram("analyze\n", &first);
10669         first.analyzing = TRUE;
10670         /*first.maybeThinking = TRUE;*/
10671         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
10672         EngineOutputPopUp();
10673     }
10674     gameMode = AnalyzeFile;
10675     pausing = FALSE;
10676     ModeHighlight();
10677     SetGameInfo();
10678
10679     StartAnalysisClock();
10680     GetTimeMark(&lastNodeCountTime);
10681     lastNodeCount = 0;
10682 }
10683
10684 void
10685 MachineWhiteEvent()
10686 {
10687     char buf[MSG_SIZ];
10688     char *bookHit = NULL;
10689
10690     if (appData.noChessProgram || (gameMode == MachinePlaysWhite))
10691       return;
10692
10693
10694     if (gameMode == PlayFromGameFile ||
10695         gameMode == TwoMachinesPlay  ||
10696         gameMode == Training         ||
10697         gameMode == AnalyzeMode      ||
10698         gameMode == EndOfGame)
10699         EditGameEvent();
10700
10701     if (gameMode == EditPosition)
10702         EditPositionDone(TRUE);
10703
10704     if (!WhiteOnMove(currentMove)) {
10705         DisplayError(_("It is not White's turn"), 0);
10706         return;
10707     }
10708
10709     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
10710       ExitAnalyzeMode();
10711
10712     if (gameMode == EditGame || gameMode == AnalyzeMode ||
10713         gameMode == AnalyzeFile)
10714         TruncateGame();
10715
10716     ResurrectChessProgram();    /* in case it isn't running */
10717     if(gameMode == BeginningOfGame) { /* [HGM] time odds: to get right odds in human mode */
10718         gameMode = MachinePlaysWhite;
10719         ResetClocks();
10720     } else
10721     gameMode = MachinePlaysWhite;
10722     pausing = FALSE;
10723     ModeHighlight();
10724     SetGameInfo();
10725     sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
10726     DisplayTitle(buf);
10727     if (first.sendName) {
10728       sprintf(buf, "name %s\n", gameInfo.black);
10729       SendToProgram(buf, &first);
10730     }
10731     if (first.sendTime) {
10732       if (first.useColors) {
10733         SendToProgram("black\n", &first); /*gnu kludge*/
10734       }
10735       SendTimeRemaining(&first, TRUE);
10736     }
10737     if (first.useColors) {
10738       SendToProgram("white\n", &first); // [HGM] book: send 'go' separately
10739     }
10740     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
10741     SetMachineThinkingEnables();
10742     first.maybeThinking = TRUE;
10743     StartClocks();
10744     firstMove = FALSE;
10745
10746     if (appData.autoFlipView && !flipView) {
10747       flipView = !flipView;
10748       DrawPosition(FALSE, NULL);
10749       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
10750     }
10751
10752     if(bookHit) { // [HGM] book: simulate book reply
10753         static char bookMove[MSG_SIZ]; // a bit generous?
10754
10755         programStats.nodes = programStats.depth = programStats.time =
10756         programStats.score = programStats.got_only_move = 0;
10757         sprintf(programStats.movelist, "%s (xbook)", bookHit);
10758
10759         strcpy(bookMove, "move ");
10760         strcat(bookMove, bookHit);
10761         HandleMachineMove(bookMove, &first);
10762     }
10763 }
10764
10765 void
10766 MachineBlackEvent()
10767 {
10768     char buf[MSG_SIZ];
10769    char *bookHit = NULL;
10770
10771     if (appData.noChessProgram || (gameMode == MachinePlaysBlack))
10772         return;
10773
10774
10775     if (gameMode == PlayFromGameFile ||
10776         gameMode == TwoMachinesPlay  ||
10777         gameMode == Training         ||
10778         gameMode == AnalyzeMode      ||
10779         gameMode == EndOfGame)
10780         EditGameEvent();
10781
10782     if (gameMode == EditPosition)
10783         EditPositionDone(TRUE);
10784
10785     if (WhiteOnMove(currentMove)) {
10786         DisplayError(_("It is not Black's turn"), 0);
10787         return;
10788     }
10789
10790     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
10791       ExitAnalyzeMode();
10792
10793     if (gameMode == EditGame || gameMode == AnalyzeMode ||
10794         gameMode == AnalyzeFile)
10795         TruncateGame();
10796
10797     ResurrectChessProgram();    /* in case it isn't running */
10798     gameMode = MachinePlaysBlack;
10799     pausing = FALSE;
10800     ModeHighlight();
10801     SetGameInfo();
10802     sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
10803     DisplayTitle(buf);
10804     if (first.sendName) {
10805       sprintf(buf, "name %s\n", gameInfo.white);
10806       SendToProgram(buf, &first);
10807     }
10808     if (first.sendTime) {
10809       if (first.useColors) {
10810         SendToProgram("white\n", &first); /*gnu kludge*/
10811       }
10812       SendTimeRemaining(&first, FALSE);
10813     }
10814     if (first.useColors) {
10815       SendToProgram("black\n", &first); // [HGM] book: 'go' sent separately
10816     }
10817     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
10818     SetMachineThinkingEnables();
10819     first.maybeThinking = TRUE;
10820     StartClocks();
10821
10822     if (appData.autoFlipView && flipView) {
10823       flipView = !flipView;
10824       DrawPosition(FALSE, NULL);
10825       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
10826     }
10827     if(bookHit) { // [HGM] book: simulate book reply
10828         static char bookMove[MSG_SIZ]; // a bit generous?
10829
10830         programStats.nodes = programStats.depth = programStats.time =
10831         programStats.score = programStats.got_only_move = 0;
10832         sprintf(programStats.movelist, "%s (xbook)", bookHit);
10833
10834         strcpy(bookMove, "move ");
10835         strcat(bookMove, bookHit);
10836         HandleMachineMove(bookMove, &first);
10837     }
10838 }
10839
10840
10841 void
10842 DisplayTwoMachinesTitle()
10843 {
10844     char buf[MSG_SIZ];
10845     if (appData.matchGames > 0) {
10846         if (first.twoMachinesColor[0] == 'w') {
10847             sprintf(buf, "%s vs. %s (%d-%d-%d)",
10848                     gameInfo.white, gameInfo.black,
10849                     first.matchWins, second.matchWins,
10850                     matchGame - 1 - (first.matchWins + second.matchWins));
10851         } else {
10852             sprintf(buf, "%s vs. %s (%d-%d-%d)",
10853                     gameInfo.white, gameInfo.black,
10854                     second.matchWins, first.matchWins,
10855                     matchGame - 1 - (first.matchWins + second.matchWins));
10856         }
10857     } else {
10858         sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
10859     }
10860     DisplayTitle(buf);
10861 }
10862
10863 void
10864 TwoMachinesEvent P((void))
10865 {
10866     int i;
10867     char buf[MSG_SIZ];
10868     ChessProgramState *onmove;
10869     char *bookHit = NULL;
10870
10871     if (appData.noChessProgram) return;
10872
10873     switch (gameMode) {
10874       case TwoMachinesPlay:
10875         return;
10876       case MachinePlaysWhite:
10877       case MachinePlaysBlack:
10878         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
10879             DisplayError(_("Wait until your turn,\nor select Move Now"), 0);
10880             return;
10881         }
10882         /* fall through */
10883       case BeginningOfGame:
10884       case PlayFromGameFile:
10885       case EndOfGame:
10886         EditGameEvent();
10887         if (gameMode != EditGame) return;
10888         break;
10889       case EditPosition:
10890         EditPositionDone(TRUE);
10891         break;
10892       case AnalyzeMode:
10893       case AnalyzeFile:
10894         ExitAnalyzeMode();
10895         break;
10896       case EditGame:
10897       default:
10898         break;
10899     }
10900
10901     forwardMostMove = currentMove;
10902     ResurrectChessProgram();    /* in case first program isn't running */
10903
10904     if (second.pr == NULL) {
10905         StartChessProgram(&second);
10906         if (second.protocolVersion == 1) {
10907           TwoMachinesEventIfReady();
10908         } else {
10909           /* kludge: allow timeout for initial "feature" command */
10910           FreezeUI();
10911           DisplayMessage("", _("Starting second chess program"));
10912           ScheduleDelayedEvent(TwoMachinesEventIfReady, FEATURE_TIMEOUT);
10913         }
10914         return;
10915     }
10916     DisplayMessage("", "");
10917     InitChessProgram(&second, FALSE);
10918     SendToProgram("force\n", &second);
10919     if (startedFromSetupPosition) {
10920         SendBoard(&second, backwardMostMove);
10921     if (appData.debugMode) {
10922         fprintf(debugFP, "Two Machines\n");
10923     }
10924     }
10925     for (i = backwardMostMove; i < forwardMostMove; i++) {
10926         SendMoveToProgram(i, &second);
10927     }
10928
10929     gameMode = TwoMachinesPlay;
10930     pausing = FALSE;
10931     ModeHighlight();
10932     SetGameInfo();
10933     DisplayTwoMachinesTitle();
10934     firstMove = TRUE;
10935     if ((first.twoMachinesColor[0] == 'w') == WhiteOnMove(forwardMostMove)) {
10936         onmove = &first;
10937     } else {
10938         onmove = &second;
10939     }
10940
10941     SendToProgram(first.computerString, &first);
10942     if (first.sendName) {
10943       sprintf(buf, "name %s\n", second.tidy);
10944       SendToProgram(buf, &first);
10945     }
10946     SendToProgram(second.computerString, &second);
10947     if (second.sendName) {
10948       sprintf(buf, "name %s\n", first.tidy);
10949       SendToProgram(buf, &second);
10950     }
10951
10952     ResetClocks();
10953     if (!first.sendTime || !second.sendTime) {
10954         timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
10955         timeRemaining[1][forwardMostMove] = blackTimeRemaining;
10956     }
10957     if (onmove->sendTime) {
10958       if (onmove->useColors) {
10959         SendToProgram(onmove->other->twoMachinesColor, onmove); /*gnu kludge*/
10960       }
10961       SendTimeRemaining(onmove, WhiteOnMove(forwardMostMove));
10962     }
10963     if (onmove->useColors) {
10964       SendToProgram(onmove->twoMachinesColor, onmove);
10965     }
10966     bookHit = SendMoveToBookUser(forwardMostMove-1, onmove, TRUE); // [HGM] book: send go or retrieve book move
10967 //    SendToProgram("go\n", onmove);
10968     onmove->maybeThinking = TRUE;
10969     SetMachineThinkingEnables();
10970
10971     StartClocks();
10972
10973     if(bookHit) { // [HGM] book: simulate book reply
10974         static char bookMove[MSG_SIZ]; // a bit generous?
10975
10976         programStats.nodes = programStats.depth = programStats.time =
10977         programStats.score = programStats.got_only_move = 0;
10978         sprintf(programStats.movelist, "%s (xbook)", bookHit);
10979
10980         strcpy(bookMove, "move ");
10981         strcat(bookMove, bookHit);
10982         savedMessage = bookMove; // args for deferred call
10983         savedState = onmove;
10984         ScheduleDelayedEvent(DeferredBookMove, 1);
10985     }
10986 }
10987
10988 void
10989 TrainingEvent()
10990 {
10991     if (gameMode == Training) {
10992       SetTrainingModeOff();
10993       gameMode = PlayFromGameFile;
10994       DisplayMessage("", _("Training mode off"));
10995     } else {
10996       gameMode = Training;
10997       animateTraining = appData.animate;
10998
10999       /* make sure we are not already at the end of the game */
11000       if (currentMove < forwardMostMove) {
11001         SetTrainingModeOn();
11002         DisplayMessage("", _("Training mode on"));
11003       } else {
11004         gameMode = PlayFromGameFile;
11005         DisplayError(_("Already at end of game"), 0);
11006       }
11007     }
11008     ModeHighlight();
11009 }
11010
11011 void
11012 IcsClientEvent()
11013 {
11014     if (!appData.icsActive) return;
11015     switch (gameMode) {
11016       case IcsPlayingWhite:
11017       case IcsPlayingBlack:
11018       case IcsObserving:
11019       case IcsIdle:
11020       case BeginningOfGame:
11021       case IcsExamining:
11022         return;
11023
11024       case EditGame:
11025         break;
11026
11027       case EditPosition:
11028         EditPositionDone(TRUE);
11029         break;
11030
11031       case AnalyzeMode:
11032       case AnalyzeFile:
11033         ExitAnalyzeMode();
11034         break;
11035
11036       default:
11037         EditGameEvent();
11038         break;
11039     }
11040
11041     gameMode = IcsIdle;
11042     ModeHighlight();
11043     return;
11044 }
11045
11046
11047 void
11048 EditGameEvent()
11049 {
11050     int i;
11051
11052     switch (gameMode) {
11053       case Training:
11054         SetTrainingModeOff();
11055         break;
11056       case MachinePlaysWhite:
11057       case MachinePlaysBlack:
11058       case BeginningOfGame:
11059         SendToProgram("force\n", &first);
11060         SetUserThinkingEnables();
11061         break;
11062       case PlayFromGameFile:
11063         (void) StopLoadGameTimer();
11064         if (gameFileFP != NULL) {
11065             gameFileFP = NULL;
11066         }
11067         break;
11068       case EditPosition:
11069         EditPositionDone(TRUE);
11070         break;
11071       case AnalyzeMode:
11072       case AnalyzeFile:
11073         ExitAnalyzeMode();
11074         SendToProgram("force\n", &first);
11075         break;
11076       case TwoMachinesPlay:
11077         GameEnds((ChessMove) 0, NULL, GE_PLAYER);
11078         ResurrectChessProgram();
11079         SetUserThinkingEnables();
11080         break;
11081       case EndOfGame:
11082         ResurrectChessProgram();
11083         break;
11084       case IcsPlayingBlack:
11085       case IcsPlayingWhite:
11086         DisplayError(_("Warning: You are still playing a game"), 0);
11087         break;
11088       case IcsObserving:
11089         DisplayError(_("Warning: You are still observing a game"), 0);
11090         break;
11091       case IcsExamining:
11092         DisplayError(_("Warning: You are still examining a game"), 0);
11093         break;
11094       case IcsIdle:
11095         break;
11096       case EditGame:
11097       default:
11098         return;
11099     }
11100
11101     pausing = FALSE;
11102     StopClocks();
11103     first.offeredDraw = second.offeredDraw = 0;
11104
11105     if (gameMode == PlayFromGameFile) {
11106         whiteTimeRemaining = timeRemaining[0][currentMove];
11107         blackTimeRemaining = timeRemaining[1][currentMove];
11108         DisplayTitle("");
11109     }
11110
11111     if (gameMode == MachinePlaysWhite ||
11112         gameMode == MachinePlaysBlack ||
11113         gameMode == TwoMachinesPlay ||
11114         gameMode == EndOfGame) {
11115         i = forwardMostMove;
11116         while (i > currentMove) {
11117             SendToProgram("undo\n", &first);
11118             i--;
11119         }
11120         whiteTimeRemaining = timeRemaining[0][currentMove];
11121         blackTimeRemaining = timeRemaining[1][currentMove];
11122         DisplayBothClocks();
11123         if (whiteFlag || blackFlag) {
11124             whiteFlag = blackFlag = 0;
11125         }
11126         DisplayTitle("");
11127     }
11128
11129     gameMode = EditGame;
11130     ModeHighlight();
11131     SetGameInfo();
11132 }
11133
11134
11135 void
11136 EditPositionEvent()
11137 {
11138     if (gameMode == EditPosition) {
11139         EditGameEvent();
11140         return;
11141     }
11142
11143     EditGameEvent();
11144     if (gameMode != EditGame) return;
11145
11146     gameMode = EditPosition;
11147     ModeHighlight();
11148     SetGameInfo();
11149     if (currentMove > 0)
11150       CopyBoard(boards[0], boards[currentMove]);
11151
11152     blackPlaysFirst = !WhiteOnMove(currentMove);
11153     ResetClocks();
11154     currentMove = forwardMostMove = backwardMostMove = 0;
11155     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
11156     DisplayMove(-1);
11157 }
11158
11159 void
11160 ExitAnalyzeMode()
11161 {
11162     /* [DM] icsEngineAnalyze - possible call from other functions */
11163     if (appData.icsEngineAnalyze) {
11164         appData.icsEngineAnalyze = FALSE;
11165
11166         DisplayMessage("",_("Close ICS engine analyze..."));
11167     }
11168     if (first.analysisSupport && first.analyzing) {
11169       SendToProgram("exit\n", &first);
11170       first.analyzing = FALSE;
11171     }
11172     thinkOutput[0] = NULLCHAR;
11173 }
11174
11175 void
11176 EditPositionDone(Boolean fakeRights)
11177 {
11178     int king = gameInfo.variant == VariantKnightmate ? WhiteUnicorn : WhiteKing;
11179
11180     startedFromSetupPosition = TRUE;
11181     InitChessProgram(&first, FALSE);
11182     if(fakeRights)
11183       { /* don't do this if we just pasted FEN */
11184         castlingRights[0][2] = castlingRights[0][5] = BOARD_WIDTH>>1;
11185         if(boards[0][0][BOARD_WIDTH>>1] == king)
11186           {
11187             castlingRights[0][1] = boards[0][0][BOARD_LEFT] == WhiteRook ? 0 : -1;
11188             castlingRights[0][0] = boards[0][0][BOARD_RGHT-1] == WhiteRook ? BOARD_RGHT-1 : -1;
11189           }
11190         else
11191           castlingRights[0][2] = -1;
11192         if(boards[0][BOARD_HEIGHT-1][BOARD_WIDTH>>1] == WHITE_TO_BLACK king)
11193           {
11194             castlingRights[0][4] = boards[0][BOARD_HEIGHT-1][BOARD_LEFT] == BlackRook ? 0 : -1;
11195             castlingRights[0][3] = boards[0][BOARD_HEIGHT-1][BOARD_RGHT-1] == BlackRook ? BOARD_RGHT-1 : -1;
11196           }
11197         else
11198           castlingRights[0][5] = -1;
11199       }
11200     SendToProgram("force\n", &first);
11201     if (blackPlaysFirst) {
11202         strcpy(moveList[0], "");
11203         strcpy(parseList[0], "");
11204         currentMove = forwardMostMove = backwardMostMove = 1;
11205         CopyBoard(boards[1], boards[0]);
11206         /* [HGM] copy rights as well, as this code is also used after pasting a FEN */
11207         { int i;
11208           epStatus[1] = epStatus[0];
11209           for(i=0; i<nrCastlingRights; i++) castlingRights[1][i] = castlingRights[0][i];
11210         }
11211     } else {
11212         currentMove = forwardMostMove = backwardMostMove = 0;
11213     }
11214     SendBoard(&first, forwardMostMove);
11215     if (appData.debugMode) {
11216         fprintf(debugFP, "EditPosDone\n");
11217     }
11218     DisplayTitle("");
11219     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
11220     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
11221     gameMode = EditGame;
11222     ModeHighlight();
11223     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
11224     ClearHighlights(); /* [AS] */
11225 }
11226
11227 /* Pause for `ms' milliseconds */
11228 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
11229 void
11230 TimeDelay(ms)
11231      long ms;
11232 {
11233     TimeMark m1, m2;
11234
11235     GetTimeMark(&m1);
11236     do {
11237         GetTimeMark(&m2);
11238     } while (SubtractTimeMarks(&m2, &m1) < ms);
11239 }
11240
11241 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
11242 void
11243 SendMultiLineToICS(buf)
11244      char *buf;
11245 {
11246     char temp[MSG_SIZ+1], *p;
11247     int len;
11248
11249     len = strlen(buf);
11250     if (len > MSG_SIZ)
11251       len = MSG_SIZ;
11252
11253     strncpy(temp, buf, len);
11254     temp[len] = 0;
11255
11256     p = temp;
11257     while (*p) {
11258         if (*p == '\n' || *p == '\r')
11259           *p = ' ';
11260         ++p;
11261     }
11262
11263     strcat(temp, "\n");
11264     SendToICS(temp);
11265     SendToPlayer(temp, strlen(temp));
11266 }
11267
11268 void
11269 SetWhiteToPlayEvent()
11270 {
11271     if (gameMode == EditPosition) {
11272         blackPlaysFirst = FALSE;
11273         DisplayBothClocks();    /* works because currentMove is 0 */
11274     } else if (gameMode == IcsExamining) {
11275         SendToICS(ics_prefix);
11276         SendToICS("tomove white\n");
11277     }
11278 }
11279
11280 void
11281 SetBlackToPlayEvent()
11282 {
11283     if (gameMode == EditPosition) {
11284         blackPlaysFirst = TRUE;
11285         currentMove = 1;        /* kludge */
11286         DisplayBothClocks();
11287         currentMove = 0;
11288     } else if (gameMode == IcsExamining) {
11289         SendToICS(ics_prefix);
11290         SendToICS("tomove black\n");
11291     }
11292 }
11293
11294 void
11295 EditPositionMenuEvent(selection, x, y)
11296      ChessSquare selection;
11297      int x, y;
11298 {
11299     char buf[MSG_SIZ];
11300     ChessSquare piece = boards[0][y][x];
11301
11302     if (gameMode != EditPosition && gameMode != IcsExamining) return;
11303
11304     switch (selection) {
11305       case ClearBoard:
11306         if (gameMode == IcsExamining && ics_type == ICS_FICS) {
11307             SendToICS(ics_prefix);
11308             SendToICS("bsetup clear\n");
11309         } else if (gameMode == IcsExamining && ics_type == ICS_ICC) {
11310             SendToICS(ics_prefix);
11311             SendToICS("clearboard\n");
11312         } else {
11313             for (x = 0; x < BOARD_WIDTH; x++) { ChessSquare p = EmptySquare;
11314                 if(x == BOARD_LEFT-1 || x == BOARD_RGHT) p = (ChessSquare) 0; /* [HGM] holdings */
11315                 for (y = 0; y < BOARD_HEIGHT; y++) {
11316                     if (gameMode == IcsExamining) {
11317                         if (boards[currentMove][y][x] != EmptySquare) {
11318                             sprintf(buf, "%sx@%c%c\n", ics_prefix,
11319                                     AAA + x, ONE + y);
11320                             SendToICS(buf);
11321                         }
11322                     } else {
11323                         boards[0][y][x] = p;
11324                     }
11325                 }
11326             }
11327         }
11328         if (gameMode == EditPosition) {
11329             DrawPosition(FALSE, boards[0]);
11330         }
11331         break;
11332
11333       case WhitePlay:
11334         SetWhiteToPlayEvent();
11335         break;
11336
11337       case BlackPlay:
11338         SetBlackToPlayEvent();
11339         break;
11340
11341       case EmptySquare:
11342         if (gameMode == IcsExamining) {
11343             sprintf(buf, "%sx@%c%c\n", ics_prefix, AAA + x, ONE + y);
11344             SendToICS(buf);
11345         } else {
11346             boards[0][y][x] = EmptySquare;
11347             DrawPosition(FALSE, boards[0]);
11348         }
11349         break;
11350
11351       case PromotePiece:
11352         if(piece >= (int)WhitePawn && piece < (int)WhiteMan ||
11353            piece >= (int)BlackPawn && piece < (int)BlackMan   ) {
11354             selection = (ChessSquare) (PROMOTED piece);
11355         } else if(piece == EmptySquare) selection = WhiteSilver;
11356         else selection = (ChessSquare)((int)piece - 1);
11357         goto defaultlabel;
11358
11359       case DemotePiece:
11360         if(piece > (int)WhiteMan && piece <= (int)WhiteKing ||
11361            piece > (int)BlackMan && piece <= (int)BlackKing   ) {
11362             selection = (ChessSquare) (DEMOTED piece);
11363         } else if(piece == EmptySquare) selection = BlackSilver;
11364         else selection = (ChessSquare)((int)piece + 1);
11365         goto defaultlabel;
11366
11367       case WhiteQueen:
11368       case BlackQueen:
11369         if(gameInfo.variant == VariantShatranj ||
11370            gameInfo.variant == VariantXiangqi  ||
11371            gameInfo.variant == VariantCourier    )
11372             selection = (ChessSquare)((int)selection - (int)WhiteQueen + (int)WhiteFerz);
11373         goto defaultlabel;
11374
11375       case WhiteKing:
11376       case BlackKing:
11377         if(gameInfo.variant == VariantXiangqi)
11378             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteWazir);
11379         if(gameInfo.variant == VariantKnightmate)
11380             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteUnicorn);
11381       default:
11382         defaultlabel:
11383         if (gameMode == IcsExamining) {
11384             sprintf(buf, "%s%c@%c%c\n", ics_prefix,
11385                     PieceToChar(selection), AAA + x, ONE + y);
11386             SendToICS(buf);
11387         } else {
11388             boards[0][y][x] = selection;
11389             DrawPosition(FALSE, boards[0]);
11390         }
11391         break;
11392     }
11393 }
11394
11395
11396 void
11397 DropMenuEvent(selection, x, y)
11398      ChessSquare selection;
11399      int x, y;
11400 {
11401     ChessMove moveType;
11402
11403     switch (gameMode) {
11404       case IcsPlayingWhite:
11405       case MachinePlaysBlack:
11406         if (!WhiteOnMove(currentMove)) {
11407             DisplayMoveError(_("It is Black's turn"));
11408             return;
11409         }
11410         moveType = WhiteDrop;
11411         break;
11412       case IcsPlayingBlack:
11413       case MachinePlaysWhite:
11414         if (WhiteOnMove(currentMove)) {
11415             DisplayMoveError(_("It is White's turn"));
11416             return;
11417         }
11418         moveType = BlackDrop;
11419         break;
11420       case EditGame:
11421         moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
11422         break;
11423       default:
11424         return;
11425     }
11426
11427     if (moveType == BlackDrop && selection < BlackPawn) {
11428       selection = (ChessSquare) ((int) selection
11429                                  + (int) BlackPawn - (int) WhitePawn);
11430     }
11431     if (boards[currentMove][y][x] != EmptySquare) {
11432         DisplayMoveError(_("That square is occupied"));
11433         return;
11434     }
11435
11436     FinishMove(moveType, (int) selection, DROP_RANK, x, y, NULLCHAR);
11437 }
11438
11439 void
11440 AcceptEvent()
11441 {
11442     /* Accept a pending offer of any kind from opponent */
11443
11444     if (appData.icsActive) {
11445         SendToICS(ics_prefix);
11446         SendToICS("accept\n");
11447     } else if (cmailMsgLoaded) {
11448         if (currentMove == cmailOldMove &&
11449             commentList[cmailOldMove] != NULL &&
11450             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
11451                    "Black offers a draw" : "White offers a draw")) {
11452             TruncateGame();
11453             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
11454             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
11455         } else {
11456             DisplayError(_("There is no pending offer on this move"), 0);
11457             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
11458         }
11459     } else {
11460         /* Not used for offers from chess program */
11461     }
11462 }
11463
11464 void
11465 DeclineEvent()
11466 {
11467     /* Decline a pending offer of any kind from opponent */
11468
11469     if (appData.icsActive) {
11470         SendToICS(ics_prefix);
11471         SendToICS("decline\n");
11472     } else if (cmailMsgLoaded) {
11473         if (currentMove == cmailOldMove &&
11474             commentList[cmailOldMove] != NULL &&
11475             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
11476                    "Black offers a draw" : "White offers a draw")) {
11477 #ifdef NOTDEF
11478             AppendComment(cmailOldMove, "Draw declined");
11479             DisplayComment(cmailOldMove - 1, "Draw declined");
11480 #endif /*NOTDEF*/
11481         } else {
11482             DisplayError(_("There is no pending offer on this move"), 0);
11483         }
11484     } else {
11485         /* Not used for offers from chess program */
11486     }
11487 }
11488
11489 void
11490 RematchEvent()
11491 {
11492     /* Issue ICS rematch command */
11493     if (appData.icsActive) {
11494         SendToICS(ics_prefix);
11495         SendToICS("rematch\n");
11496     }
11497 }
11498
11499 void
11500 CallFlagEvent()
11501 {
11502     /* Call your opponent's flag (claim a win on time) */
11503     if (appData.icsActive) {
11504         SendToICS(ics_prefix);
11505         SendToICS("flag\n");
11506     } else {
11507         switch (gameMode) {
11508           default:
11509             return;
11510           case MachinePlaysWhite:
11511             if (whiteFlag) {
11512                 if (blackFlag)
11513                   GameEnds(GameIsDrawn, "Both players ran out of time",
11514                            GE_PLAYER);
11515                 else
11516                   GameEnds(BlackWins, "Black wins on time", GE_PLAYER);
11517             } else {
11518                 DisplayError(_("Your opponent is not out of time"), 0);
11519             }
11520             break;
11521           case MachinePlaysBlack:
11522             if (blackFlag) {
11523                 if (whiteFlag)
11524                   GameEnds(GameIsDrawn, "Both players ran out of time",
11525                            GE_PLAYER);
11526                 else
11527                   GameEnds(WhiteWins, "White wins on time", GE_PLAYER);
11528             } else {
11529                 DisplayError(_("Your opponent is not out of time"), 0);
11530             }
11531             break;
11532         }
11533     }
11534 }
11535
11536 void
11537 DrawEvent()
11538 {
11539     /* Offer draw or accept pending draw offer from opponent */
11540
11541     if (appData.icsActive) {
11542         /* Note: tournament rules require draw offers to be
11543            made after you make your move but before you punch
11544            your clock.  Currently ICS doesn't let you do that;
11545            instead, you immediately punch your clock after making
11546            a move, but you can offer a draw at any time. */
11547
11548         SendToICS(ics_prefix);
11549         SendToICS("draw\n");
11550     } else if (cmailMsgLoaded) {
11551         if (currentMove == cmailOldMove &&
11552             commentList[cmailOldMove] != NULL &&
11553             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
11554                    "Black offers a draw" : "White offers a draw")) {
11555             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
11556             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
11557         } else if (currentMove == cmailOldMove + 1) {
11558             char *offer = WhiteOnMove(cmailOldMove) ?
11559               "White offers a draw" : "Black offers a draw";
11560             AppendComment(currentMove, offer);
11561             DisplayComment(currentMove - 1, offer);
11562             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_DRAW;
11563         } else {
11564             DisplayError(_("You must make your move before offering a draw"), 0);
11565             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
11566         }
11567     } else if (first.offeredDraw) {
11568         GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
11569     } else {
11570         if (first.sendDrawOffers) {
11571             SendToProgram("draw\n", &first);
11572             userOfferedDraw = TRUE;
11573         }
11574     }
11575 }
11576
11577 void
11578 AdjournEvent()
11579 {
11580     /* Offer Adjourn or accept pending Adjourn offer from opponent */
11581
11582     if (appData.icsActive) {
11583         SendToICS(ics_prefix);
11584         SendToICS("adjourn\n");
11585     } else {
11586         /* Currently GNU Chess doesn't offer or accept Adjourns */
11587     }
11588 }
11589
11590
11591 void
11592 AbortEvent()
11593 {
11594     /* Offer Abort or accept pending Abort offer from opponent */
11595
11596     if (appData.icsActive) {
11597         SendToICS(ics_prefix);
11598         SendToICS("abort\n");
11599     } else {
11600         GameEnds(GameUnfinished, "Game aborted", GE_PLAYER);
11601     }
11602 }
11603
11604 void
11605 ResignEvent()
11606 {
11607     /* Resign.  You can do this even if it's not your turn. */
11608
11609     if (appData.icsActive) {
11610         SendToICS(ics_prefix);
11611         SendToICS("resign\n");
11612     } else {
11613         switch (gameMode) {
11614           case MachinePlaysWhite:
11615             GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
11616             break;
11617           case MachinePlaysBlack:
11618             GameEnds(BlackWins, "White resigns", GE_PLAYER);
11619             break;
11620           case EditGame:
11621             if (cmailMsgLoaded) {
11622                 TruncateGame();
11623                 if (WhiteOnMove(cmailOldMove)) {
11624                     GameEnds(BlackWins, "White resigns", GE_PLAYER);
11625                 } else {
11626                     GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
11627                 }
11628                 cmailMoveType[lastLoadGameNumber - 1] = CMAIL_RESIGN;
11629             }
11630             break;
11631           default:
11632             break;
11633         }
11634     }
11635 }
11636
11637
11638 void
11639 StopObservingEvent()
11640 {
11641     /* Stop observing current games */
11642     SendToICS(ics_prefix);
11643     SendToICS("unobserve\n");
11644 }
11645
11646 void
11647 StopExaminingEvent()
11648 {
11649     /* Stop observing current game */
11650     SendToICS(ics_prefix);
11651     SendToICS("unexamine\n");
11652 }
11653
11654 void
11655 ForwardInner(target)
11656      int target;
11657 {
11658     int limit;
11659
11660     if (appData.debugMode)
11661         fprintf(debugFP, "ForwardInner(%d), current %d, forward %d\n",
11662                 target, currentMove, forwardMostMove);
11663
11664     if (gameMode == EditPosition)
11665       return;
11666
11667     if (gameMode == PlayFromGameFile && !pausing)
11668       PauseEvent();
11669
11670     if (gameMode == IcsExamining && pausing)
11671       limit = pauseExamForwardMostMove;
11672     else
11673       limit = forwardMostMove;
11674
11675     if (target > limit) target = limit;
11676
11677     if (target > 0 && moveList[target - 1][0]) {
11678         int fromX, fromY, toX, toY;
11679         toX = moveList[target - 1][2] - AAA;
11680         toY = moveList[target - 1][3] - ONE;
11681         if (moveList[target - 1][1] == '@') {
11682             if (appData.highlightLastMove) {
11683                 SetHighlights(-1, -1, toX, toY);
11684             }
11685         } else {
11686             fromX = moveList[target - 1][0] - AAA;
11687             fromY = moveList[target - 1][1] - ONE;
11688             if (target == currentMove + 1) {
11689                 AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
11690             }
11691             if (appData.highlightLastMove) {
11692                 SetHighlights(fromX, fromY, toX, toY);
11693             }
11694         }
11695     }
11696     if (gameMode == EditGame || gameMode == AnalyzeMode ||
11697         gameMode == Training || gameMode == PlayFromGameFile ||
11698         gameMode == AnalyzeFile) {
11699         while (currentMove < target) {
11700             SendMoveToProgram(currentMove++, &first);
11701         }
11702     } else {
11703         currentMove = target;
11704     }
11705
11706     if (gameMode == EditGame || gameMode == EndOfGame) {
11707         whiteTimeRemaining = timeRemaining[0][currentMove];
11708         blackTimeRemaining = timeRemaining[1][currentMove];
11709     }
11710     DisplayBothClocks();
11711     DisplayMove(currentMove - 1);
11712     DrawPosition(FALSE, boards[currentMove]);
11713     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
11714     if ( !matchMode && gameMode != Training) { // [HGM] PV info: routine tests if empty
11715         DisplayComment(currentMove - 1, commentList[currentMove]);
11716     }
11717 }
11718
11719
11720 void
11721 ForwardEvent()
11722 {
11723     if (gameMode == IcsExamining && !pausing) {
11724         SendToICS(ics_prefix);
11725         SendToICS("forward\n");
11726     } else {
11727         ForwardInner(currentMove + 1);
11728     }
11729 }
11730
11731 void
11732 ToEndEvent()
11733 {
11734     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
11735         /* to optimze, we temporarily turn off analysis mode while we feed
11736          * the remaining moves to the engine. Otherwise we get analysis output
11737          * after each move.
11738          */
11739         if (first.analysisSupport) {
11740           SendToProgram("exit\nforce\n", &first);
11741           first.analyzing = FALSE;
11742         }
11743     }
11744
11745     if (gameMode == IcsExamining && !pausing) {
11746         SendToICS(ics_prefix);
11747         SendToICS("forward 999999\n");
11748     } else {
11749         ForwardInner(forwardMostMove);
11750     }
11751
11752     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
11753         /* we have fed all the moves, so reactivate analysis mode */
11754         SendToProgram("analyze\n", &first);
11755         first.analyzing = TRUE;
11756         /*first.maybeThinking = TRUE;*/
11757         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
11758     }
11759 }
11760
11761 void
11762 BackwardInner(target)
11763      int target;
11764 {
11765     int full_redraw = TRUE; /* [AS] Was FALSE, had to change it! */
11766
11767     if (appData.debugMode)
11768         fprintf(debugFP, "BackwardInner(%d), current %d, forward %d\n",
11769                 target, currentMove, forwardMostMove);
11770
11771     if (gameMode == EditPosition) return;
11772     if (currentMove <= backwardMostMove) {
11773         ClearHighlights();
11774         DrawPosition(full_redraw, boards[currentMove]);
11775         return;
11776     }
11777     if (gameMode == PlayFromGameFile && !pausing)
11778       PauseEvent();
11779
11780     if (moveList[target][0]) {
11781         int fromX, fromY, toX, toY;
11782         toX = moveList[target][2] - AAA;
11783         toY = moveList[target][3] - ONE;
11784         if (moveList[target][1] == '@') {
11785             if (appData.highlightLastMove) {
11786                 SetHighlights(-1, -1, toX, toY);
11787             }
11788         } else {
11789             fromX = moveList[target][0] - AAA;
11790             fromY = moveList[target][1] - ONE;
11791             if (target == currentMove - 1) {
11792                 AnimateMove(boards[currentMove], toX, toY, fromX, fromY);
11793             }
11794             if (appData.highlightLastMove) {
11795                 SetHighlights(fromX, fromY, toX, toY);
11796             }
11797         }
11798     }
11799     if (gameMode == EditGame || gameMode==AnalyzeMode ||
11800         gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
11801         while (currentMove > target) {
11802             SendToProgram("undo\n", &first);
11803             currentMove--;
11804         }
11805     } else {
11806         currentMove = target;
11807     }
11808
11809     if (gameMode == EditGame || gameMode == EndOfGame) {
11810         whiteTimeRemaining = timeRemaining[0][currentMove];
11811         blackTimeRemaining = timeRemaining[1][currentMove];
11812     }
11813     DisplayBothClocks();
11814     DisplayMove(currentMove - 1);
11815     DrawPosition(full_redraw, boards[currentMove]);
11816     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
11817     // [HGM] PV info: routine tests if comment empty
11818     DisplayComment(currentMove - 1, commentList[currentMove]);
11819 }
11820
11821 void
11822 BackwardEvent()
11823 {
11824     if (gameMode == IcsExamining && !pausing) {
11825         SendToICS(ics_prefix);
11826         SendToICS("backward\n");
11827     } else {
11828         BackwardInner(currentMove - 1);
11829     }
11830 }
11831
11832 void
11833 ToStartEvent()
11834 {
11835     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
11836         /* to optimize, we temporarily turn off analysis mode while we undo
11837          * all the moves. Otherwise we get analysis output after each undo.
11838          */
11839         if (first.analysisSupport) {
11840           SendToProgram("exit\nforce\n", &first);
11841           first.analyzing = FALSE;
11842         }
11843     }
11844
11845     if (gameMode == IcsExamining && !pausing) {
11846         SendToICS(ics_prefix);
11847         SendToICS("backward 999999\n");
11848     } else {
11849         BackwardInner(backwardMostMove);
11850     }
11851
11852     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
11853         /* we have fed all the moves, so reactivate analysis mode */
11854         SendToProgram("analyze\n", &first);
11855         first.analyzing = TRUE;
11856         /*first.maybeThinking = TRUE;*/
11857         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
11858     }
11859 }
11860
11861 void
11862 ToNrEvent(int to)
11863 {
11864   if (gameMode == PlayFromGameFile && !pausing) PauseEvent();
11865   if (to >= forwardMostMove) to = forwardMostMove;
11866   if (to <= backwardMostMove) to = backwardMostMove;
11867   if (to < currentMove) {
11868     BackwardInner(to);
11869   } else {
11870     ForwardInner(to);
11871   }
11872 }
11873
11874 void
11875 RevertEvent()
11876 {
11877     if (gameMode != IcsExamining) {
11878         DisplayError(_("You are not examining a game"), 0);
11879         return;
11880     }
11881     if (pausing) {
11882         DisplayError(_("You can't revert while pausing"), 0);
11883         return;
11884     }
11885     SendToICS(ics_prefix);
11886     SendToICS("revert\n");
11887 }
11888
11889 void
11890 RetractMoveEvent()
11891 {
11892     switch (gameMode) {
11893       case MachinePlaysWhite:
11894       case MachinePlaysBlack:
11895         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
11896             DisplayError(_("Wait until your turn,\nor select Move Now"), 0);
11897             return;
11898         }
11899         if (forwardMostMove < 2) return;
11900         currentMove = forwardMostMove = forwardMostMove - 2;
11901         whiteTimeRemaining = timeRemaining[0][currentMove];
11902         blackTimeRemaining = timeRemaining[1][currentMove];
11903         DisplayBothClocks();
11904         DisplayMove(currentMove - 1);
11905         ClearHighlights();/*!! could figure this out*/
11906         DrawPosition(TRUE, boards[currentMove]); /* [AS] Changed to full redraw! */
11907         SendToProgram("remove\n", &first);
11908         /*first.maybeThinking = TRUE;*/ /* GNU Chess does not ponder here */
11909         break;
11910
11911       case BeginningOfGame:
11912       default:
11913         break;
11914
11915       case IcsPlayingWhite:
11916       case IcsPlayingBlack:
11917         if (WhiteOnMove(forwardMostMove) == (gameMode == IcsPlayingWhite)) {
11918             SendToICS(ics_prefix);
11919             SendToICS("takeback 2\n");
11920         } else {
11921             SendToICS(ics_prefix);
11922             SendToICS("takeback 1\n");
11923         }
11924         break;
11925     }
11926 }
11927
11928 void
11929 MoveNowEvent()
11930 {
11931     ChessProgramState *cps;
11932
11933     switch (gameMode) {
11934       case MachinePlaysWhite:
11935         if (!WhiteOnMove(forwardMostMove)) {
11936             DisplayError(_("It is your turn"), 0);
11937             return;
11938         }
11939         cps = &first;
11940         break;
11941       case MachinePlaysBlack:
11942         if (WhiteOnMove(forwardMostMove)) {
11943             DisplayError(_("It is your turn"), 0);
11944             return;
11945         }
11946         cps = &first;
11947         break;
11948       case TwoMachinesPlay:
11949         if (WhiteOnMove(forwardMostMove) ==
11950             (first.twoMachinesColor[0] == 'w')) {
11951             cps = &first;
11952         } else {
11953             cps = &second;
11954         }
11955         break;
11956       case BeginningOfGame:
11957       default:
11958         return;
11959     }
11960     SendToProgram("?\n", cps);
11961 }
11962
11963 void
11964 TruncateGameEvent()
11965 {
11966     EditGameEvent();
11967     if (gameMode != EditGame) return;
11968     TruncateGame();
11969 }
11970
11971 void
11972 TruncateGame()
11973 {
11974     if (forwardMostMove > currentMove) {
11975         if (gameInfo.resultDetails != NULL) {
11976             free(gameInfo.resultDetails);
11977             gameInfo.resultDetails = NULL;
11978             gameInfo.result = GameUnfinished;
11979         }
11980         forwardMostMove = currentMove;
11981         HistorySet(parseList, backwardMostMove, forwardMostMove,
11982                    currentMove-1);
11983     }
11984 }
11985
11986 void
11987 HintEvent()
11988 {
11989     if (appData.noChessProgram) return;
11990     switch (gameMode) {
11991       case MachinePlaysWhite:
11992         if (WhiteOnMove(forwardMostMove)) {
11993             DisplayError(_("Wait until your turn"), 0);
11994             return;
11995         }
11996         break;
11997       case BeginningOfGame:
11998       case MachinePlaysBlack:
11999         if (!WhiteOnMove(forwardMostMove)) {
12000             DisplayError(_("Wait until your turn"), 0);
12001             return;
12002         }
12003         break;
12004       default:
12005         DisplayError(_("No hint available"), 0);
12006         return;
12007     }
12008     SendToProgram("hint\n", &first);
12009     hintRequested = TRUE;
12010 }
12011
12012 void
12013 BookEvent()
12014 {
12015     if (appData.noChessProgram) return;
12016     switch (gameMode) {
12017       case MachinePlaysWhite:
12018         if (WhiteOnMove(forwardMostMove)) {
12019             DisplayError(_("Wait until your turn"), 0);
12020             return;
12021         }
12022         break;
12023       case BeginningOfGame:
12024       case MachinePlaysBlack:
12025         if (!WhiteOnMove(forwardMostMove)) {
12026             DisplayError(_("Wait until your turn"), 0);
12027             return;
12028         }
12029         break;
12030       case EditPosition:
12031         EditPositionDone(TRUE);
12032         break;
12033       case TwoMachinesPlay:
12034         return;
12035       default:
12036         break;
12037     }
12038     SendToProgram("bk\n", &first);
12039     bookOutput[0] = NULLCHAR;
12040     bookRequested = TRUE;
12041 }
12042
12043 void
12044 AboutGameEvent()
12045 {
12046     char *tags = PGNTags(&gameInfo);
12047     TagsPopUp(tags, CmailMsg());
12048     free(tags);
12049 }
12050
12051 /* end button procedures */
12052
12053 void
12054 PrintPosition(fp, move)
12055      FILE *fp;
12056      int move;
12057 {
12058     int i, j;
12059
12060     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
12061         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
12062             char c = PieceToChar(boards[move][i][j]);
12063             fputc(c == 'x' ? '.' : c, fp);
12064             fputc(j == BOARD_RGHT - 1 ? '\n' : ' ', fp);
12065         }
12066     }
12067     if ((gameMode == EditPosition) ? !blackPlaysFirst : (move % 2 == 0))
12068       fprintf(fp, "white to play\n");
12069     else
12070       fprintf(fp, "black to play\n");
12071 }
12072
12073 void
12074 PrintOpponents(fp)
12075      FILE *fp;
12076 {
12077     if (gameInfo.white != NULL) {
12078         fprintf(fp, "\t%s vs. %s\n", gameInfo.white, gameInfo.black);
12079     } else {
12080         fprintf(fp, "\n");
12081     }
12082 }
12083
12084 /* Find last component of program's own name, using some heuristics */
12085 void
12086 TidyProgramName(prog, host, buf)
12087      char *prog, *host, buf[MSG_SIZ];
12088 {
12089     char *p, *q;
12090     int local = (strcmp(host, "localhost") == 0);
12091     while (!local && (p = strchr(prog, ';')) != NULL) {
12092         p++;
12093         while (*p == ' ') p++;
12094         prog = p;
12095     }
12096     if (*prog == '"' || *prog == '\'') {
12097         q = strchr(prog + 1, *prog);
12098     } else {
12099         q = strchr(prog, ' ');
12100     }
12101     if (q == NULL) q = prog + strlen(prog);
12102     p = q;
12103     while (p >= prog && *p != '/' && *p != '\\') p--;
12104     p++;
12105     if(p == prog && *p == '"') p++;
12106     if (q - p >= 4 && StrCaseCmp(q - 4, ".exe") == 0) q -= 4;
12107     memcpy(buf, p, q - p);
12108     buf[q - p] = NULLCHAR;
12109     if (!local) {
12110         strcat(buf, "@");
12111         strcat(buf, host);
12112     }
12113 }
12114
12115 char *
12116 TimeControlTagValue()
12117 {
12118     char buf[MSG_SIZ];
12119     if (!appData.clockMode) {
12120         strcpy(buf, "-");
12121     } else if (movesPerSession > 0) {
12122         sprintf(buf, "%d/%ld", movesPerSession, timeControl/1000);
12123     } else if (timeIncrement == 0) {
12124         sprintf(buf, "%ld", timeControl/1000);
12125     } else {
12126         sprintf(buf, "%ld+%ld", timeControl/1000, timeIncrement/1000);
12127     }
12128     return StrSave(buf);
12129 }
12130
12131 void
12132 SetGameInfo()
12133 {
12134     /* This routine is used only for certain modes */
12135     VariantClass v = gameInfo.variant;
12136     ClearGameInfo(&gameInfo);
12137     gameInfo.variant = v;
12138
12139     switch (gameMode) {
12140       case MachinePlaysWhite:
12141         gameInfo.event = StrSave( appData.pgnEventHeader );
12142         gameInfo.site = StrSave(HostName());
12143         gameInfo.date = PGNDate();
12144         gameInfo.round = StrSave("-");
12145         gameInfo.white = StrSave(first.tidy);
12146         gameInfo.black = StrSave(UserName());
12147         gameInfo.timeControl = TimeControlTagValue();
12148         break;
12149
12150       case MachinePlaysBlack:
12151         gameInfo.event = StrSave( appData.pgnEventHeader );
12152         gameInfo.site = StrSave(HostName());
12153         gameInfo.date = PGNDate();
12154         gameInfo.round = StrSave("-");
12155         gameInfo.white = StrSave(UserName());
12156         gameInfo.black = StrSave(first.tidy);
12157         gameInfo.timeControl = TimeControlTagValue();
12158         break;
12159
12160       case TwoMachinesPlay:
12161         gameInfo.event = StrSave( appData.pgnEventHeader );
12162         gameInfo.site = StrSave(HostName());
12163         gameInfo.date = PGNDate();
12164         if (matchGame > 0) {
12165             char buf[MSG_SIZ];
12166             sprintf(buf, "%d", matchGame);
12167             gameInfo.round = StrSave(buf);
12168         } else {
12169             gameInfo.round = StrSave("-");
12170         }
12171         if (first.twoMachinesColor[0] == 'w') {
12172             gameInfo.white = StrSave(first.tidy);
12173             gameInfo.black = StrSave(second.tidy);
12174         } else {
12175             gameInfo.white = StrSave(second.tidy);
12176             gameInfo.black = StrSave(first.tidy);
12177         }
12178         gameInfo.timeControl = TimeControlTagValue();
12179         break;
12180
12181       case EditGame:
12182         gameInfo.event = StrSave("Edited game");
12183         gameInfo.site = StrSave(HostName());
12184         gameInfo.date = PGNDate();
12185         gameInfo.round = StrSave("-");
12186         gameInfo.white = StrSave("-");
12187         gameInfo.black = StrSave("-");
12188         break;
12189
12190       case EditPosition:
12191         gameInfo.event = StrSave("Edited position");
12192         gameInfo.site = StrSave(HostName());
12193         gameInfo.date = PGNDate();
12194         gameInfo.round = StrSave("-");
12195         gameInfo.white = StrSave("-");
12196         gameInfo.black = StrSave("-");
12197         break;
12198
12199       case IcsPlayingWhite:
12200       case IcsPlayingBlack:
12201       case IcsObserving:
12202       case IcsExamining:
12203         break;
12204
12205       case PlayFromGameFile:
12206         gameInfo.event = StrSave("Game from non-PGN file");
12207         gameInfo.site = StrSave(HostName());
12208         gameInfo.date = PGNDate();
12209         gameInfo.round = StrSave("-");
12210         gameInfo.white = StrSave("?");
12211         gameInfo.black = StrSave("?");
12212         break;
12213
12214       default:
12215         break;
12216     }
12217 }
12218
12219 void
12220 ReplaceComment(index, text)
12221      int index;
12222      char *text;
12223 {
12224     int len;
12225
12226     while (*text == '\n') text++;
12227     len = strlen(text);
12228     while (len > 0 && text[len - 1] == '\n') len--;
12229
12230     if (commentList[index] != NULL)
12231       free(commentList[index]);
12232
12233     if (len == 0) {
12234         commentList[index] = NULL;
12235         return;
12236     }
12237     commentList[index] = (char *) malloc(len + 2);
12238     strncpy(commentList[index], text, len);
12239     commentList[index][len] = '\n';
12240     commentList[index][len + 1] = NULLCHAR;
12241 }
12242
12243 void
12244 CrushCRs(text)
12245      char *text;
12246 {
12247   char *p = text;
12248   char *q = text;
12249   char ch;
12250
12251   do {
12252     ch = *p++;
12253     if (ch == '\r') continue;
12254     *q++ = ch;
12255   } while (ch != '\0');
12256 }
12257
12258 void
12259 AppendComment(index, text)
12260      int index;
12261      char *text;
12262 {
12263     int oldlen, len;
12264     char *old;
12265
12266     text = GetInfoFromComment( index, text ); /* [HGM] PV time: strip PV info from comment */
12267
12268     CrushCRs(text);
12269     while (*text == '\n') text++;
12270     len = strlen(text);
12271     while (len > 0 && text[len - 1] == '\n') len--;
12272
12273     if (len == 0) return;
12274
12275     if (commentList[index] != NULL) {
12276         old = commentList[index];
12277         oldlen = strlen(old);
12278         commentList[index] = (char *) malloc(oldlen + len + 2);
12279         strcpy(commentList[index], old);
12280         free(old);
12281         strncpy(&commentList[index][oldlen], text, len);
12282         commentList[index][oldlen + len] = '\n';
12283         commentList[index][oldlen + len + 1] = NULLCHAR;
12284     } else {
12285         commentList[index] = (char *) malloc(len + 2);
12286         strncpy(commentList[index], text, len);
12287         commentList[index][len] = '\n';
12288         commentList[index][len + 1] = NULLCHAR;
12289     }
12290 }
12291
12292 static char * FindStr( char * text, char * sub_text )
12293 {
12294     char * result = strstr( text, sub_text );
12295
12296     if( result != NULL ) {
12297         result += strlen( sub_text );
12298     }
12299
12300     return result;
12301 }
12302
12303 /* [AS] Try to extract PV info from PGN comment */
12304 /* [HGM] PV time: and then remove it, to prevent it appearing twice */
12305 char *GetInfoFromComment( int index, char * text )
12306 {
12307     char * sep = text;
12308
12309     if( text != NULL && index > 0 ) {
12310         int score = 0;
12311         int depth = 0;
12312         int time = -1, sec = 0, deci;
12313         char * s_eval = FindStr( text, "[%eval " );
12314         char * s_emt = FindStr( text, "[%emt " );
12315
12316         if( s_eval != NULL || s_emt != NULL ) {
12317             /* New style */
12318             char delim;
12319
12320             if( s_eval != NULL ) {
12321                 if( sscanf( s_eval, "%d,%d%c", &score, &depth, &delim ) != 3 ) {
12322                     return text;
12323                 }
12324
12325                 if( delim != ']' ) {
12326                     return text;
12327                 }
12328             }
12329
12330             if( s_emt != NULL ) {
12331             }
12332         }
12333         else {
12334             /* We expect something like: [+|-]nnn.nn/dd */
12335             int score_lo = 0;
12336
12337             sep = strchr( text, '/' );
12338             if( sep == NULL || sep < (text+4) ) {
12339                 return text;
12340             }
12341
12342             time = -1; sec = -1; deci = -1;
12343             if( sscanf( text, "%d.%d/%d %d:%d", &score, &score_lo, &depth, &time, &sec ) != 5 &&
12344                 sscanf( text, "%d.%d/%d %d.%d", &score, &score_lo, &depth, &time, &deci ) != 5 &&
12345                 sscanf( text, "%d.%d/%d %d", &score, &score_lo, &depth, &time ) != 4 &&
12346                 sscanf( text, "%d.%d/%d", &score, &score_lo, &depth ) != 3   ) {
12347                 return text;
12348             }
12349
12350             if( score_lo < 0 || score_lo >= 100 ) {
12351                 return text;
12352             }
12353
12354             if(sec >= 0) time = 600*time + 10*sec; else
12355             if(deci >= 0) time = 10*time + deci; else time *= 10; // deci-sec
12356
12357             score = score >= 0 ? score*100 + score_lo : score*100 - score_lo;
12358
12359             /* [HGM] PV time: now locate end of PV info */
12360             while( *++sep >= '0' && *sep <= '9'); // strip depth
12361             if(time >= 0)
12362             while( *++sep >= '0' && *sep <= '9'); // strip time
12363             if(sec >= 0)
12364             while( *++sep >= '0' && *sep <= '9'); // strip seconds
12365             if(deci >= 0)
12366             while( *++sep >= '0' && *sep <= '9'); // strip fractional seconds
12367             while(*sep == ' ') sep++;
12368         }
12369
12370         if( depth <= 0 ) {
12371             return text;
12372         }
12373
12374         if( time < 0 ) {
12375             time = -1;
12376         }
12377
12378         pvInfoList[index-1].depth = depth;
12379         pvInfoList[index-1].score = score;
12380         pvInfoList[index-1].time  = 10*time; // centi-sec
12381     }
12382     return sep;
12383 }
12384
12385 void
12386 SendToProgram(message, cps)
12387      char *message;
12388      ChessProgramState *cps;
12389 {
12390     int count, outCount, error;
12391     char buf[MSG_SIZ];
12392
12393     if (cps->pr == NULL) return;
12394     Attention(cps);
12395
12396     if (appData.debugMode) {
12397         TimeMark now;
12398         GetTimeMark(&now);
12399         fprintf(debugFP, "%ld >%-6s: %s",
12400                 SubtractTimeMarks(&now, &programStartTime),
12401                 cps->which, message);
12402     }
12403
12404     count = strlen(message);
12405     outCount = OutputToProcess(cps->pr, message, count, &error);
12406     if (outCount < count && !exiting
12407                          && !endingGame) { /* [HGM] crash: to not hang GameEnds() writing to deceased engines */
12408         sprintf(buf, _("Error writing to %s chess program"), cps->which);
12409         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
12410             if(epStatus[forwardMostMove] <= EP_DRAWS) {
12411                 gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
12412                 sprintf(buf, "%s program exits in draw position (%s)", cps->which, cps->program);
12413             } else {
12414                 gameInfo.result = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
12415             }
12416             gameInfo.resultDetails = StrSave(buf);
12417         }
12418         DisplayFatalError(buf, error, 1);
12419     }
12420 }
12421
12422 void
12423 ReceiveFromProgram(isr, closure, message, count, error)
12424      InputSourceRef isr;
12425      VOIDSTAR closure;
12426      char *message;
12427      int count;
12428      int error;
12429 {
12430     char *end_str;
12431     char buf[MSG_SIZ];
12432     ChessProgramState *cps = (ChessProgramState *)closure;
12433
12434     if (isr != cps->isr) return; /* Killed intentionally */
12435     if (count <= 0) {
12436         if (count == 0) {
12437             sprintf(buf,
12438                     _("Error: %s chess program (%s) exited unexpectedly"),
12439                     cps->which, cps->program);
12440         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
12441                 if(epStatus[forwardMostMove] <= EP_DRAWS) {
12442                     gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
12443                     sprintf(buf, _("%s program exits in draw position (%s)"), cps->which, cps->program);
12444                 } else {
12445                     gameInfo.result = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
12446                 }
12447                 gameInfo.resultDetails = StrSave(buf);
12448             }
12449             RemoveInputSource(cps->isr);
12450             DisplayFatalError(buf, 0, 1);
12451         } else {
12452             sprintf(buf,
12453                     _("Error reading from %s chess program (%s)"),
12454                     cps->which, cps->program);
12455             RemoveInputSource(cps->isr);
12456
12457             /* [AS] Program is misbehaving badly... kill it */
12458             if( count == -2 ) {
12459                 DestroyChildProcess( cps->pr, 9 );
12460                 cps->pr = NoProc;
12461             }
12462
12463             DisplayFatalError(buf, error, 1);
12464         }
12465         return;
12466     }
12467
12468     if ((end_str = strchr(message, '\r')) != NULL)
12469       *end_str = NULLCHAR;
12470     if ((end_str = strchr(message, '\n')) != NULL)
12471       *end_str = NULLCHAR;
12472
12473     if (appData.debugMode) {
12474         TimeMark now; int print = 1;
12475         char *quote = ""; char c; int i;
12476
12477         if(appData.engineComments != 1) { /* [HGM] debug: decide if protocol-violating output is written */
12478                 char start = message[0];
12479                 if(start >='A' && start <= 'Z') start += 'a' - 'A'; // be tolerant to capitalizing
12480                 if(sscanf(message, "%d%c%d%d%d", &i, &c, &i, &i, &i) != 5 &&
12481                    sscanf(message, "move %c", &c)!=1  && sscanf(message, "offer%c", &c)!=1 &&
12482                    sscanf(message, "resign%c", &c)!=1 && sscanf(message, "feature %c", &c)!=1 &&
12483                    sscanf(message, "error %c", &c)!=1 && sscanf(message, "illegal %c", &c)!=1 &&
12484                    sscanf(message, "tell%c", &c)!=1   && sscanf(message, "0-1 %c", &c)!=1 &&
12485                    sscanf(message, "1-0 %c", &c)!=1   && sscanf(message, "1/2-1/2 %c", &c)!=1 &&
12486                    sscanf(message, "pong %c", &c)!=1   && start != '#')
12487                         { quote = "# "; print = (appData.engineComments == 2); }
12488                 message[0] = start; // restore original message
12489         }
12490         if(print) {
12491                 GetTimeMark(&now);
12492                 fprintf(debugFP, "%ld <%-6s: %s%s\n",
12493                         SubtractTimeMarks(&now, &programStartTime), cps->which,
12494                         quote,
12495                         message);
12496         }
12497     }
12498
12499     /* [DM] if icsEngineAnalyze is active we block all whisper and kibitz output, because nobody want to see this */
12500     if (appData.icsEngineAnalyze) {
12501         if (strstr(message, "whisper") != NULL ||
12502              strstr(message, "kibitz") != NULL ||
12503             strstr(message, "tellics") != NULL) return;
12504     }
12505
12506     HandleMachineMove(message, cps);
12507 }
12508
12509
12510 void
12511 SendTimeControl(cps, mps, tc, inc, sd, st)
12512      ChessProgramState *cps;
12513      int mps, inc, sd, st;
12514      long tc;
12515 {
12516     char buf[MSG_SIZ];
12517     int seconds;
12518
12519     if( timeControl_2 > 0 ) {
12520         if( (gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b') ) {
12521             tc = timeControl_2;
12522         }
12523     }
12524     tc  /= cps->timeOdds; /* [HGM] time odds: apply before telling engine */
12525     inc /= cps->timeOdds;
12526     st  /= cps->timeOdds;
12527
12528     seconds = (tc / 1000) % 60; /* [HGM] displaced to after applying odds */
12529
12530     if (st > 0) {
12531       /* Set exact time per move, normally using st command */
12532       if (cps->stKludge) {
12533         /* GNU Chess 4 has no st command; uses level in a nonstandard way */
12534         seconds = st % 60;
12535         if (seconds == 0) {
12536           sprintf(buf, "level 1 %d\n", st/60);
12537         } else {
12538           sprintf(buf, "level 1 %d:%02d\n", st/60, seconds);
12539         }
12540       } else {
12541         sprintf(buf, "st %d\n", st);
12542       }
12543     } else {
12544       /* Set conventional or incremental time control, using level command */
12545       if (seconds == 0) {
12546         /* Note old gnuchess bug -- minutes:seconds used to not work.
12547            Fixed in later versions, but still avoid :seconds
12548            when seconds is 0. */
12549         sprintf(buf, "level %d %ld %d\n", mps, tc/60000, inc/1000);
12550       } else {
12551         sprintf(buf, "level %d %ld:%02d %d\n", mps, tc/60000,
12552                 seconds, inc/1000);
12553       }
12554     }
12555     SendToProgram(buf, cps);
12556
12557     /* Orthoganally (except for GNU Chess 4), limit time to st seconds */
12558     /* Orthogonally, limit search to given depth */
12559     if (sd > 0) {
12560       if (cps->sdKludge) {
12561         sprintf(buf, "depth\n%d\n", sd);
12562       } else {
12563         sprintf(buf, "sd %d\n", sd);
12564       }
12565       SendToProgram(buf, cps);
12566     }
12567
12568     if(cps->nps > 0) { /* [HGM] nps */
12569         if(cps->supportsNPS == FALSE) cps->nps = -1; // don't use if engine explicitly says not supported!
12570         else {
12571                 sprintf(buf, "nps %d\n", cps->nps);
12572               SendToProgram(buf, cps);
12573         }
12574     }
12575 }
12576
12577 ChessProgramState *WhitePlayer()
12578 /* [HGM] return pointer to 'first' or 'second', depending on who plays white */
12579 {
12580     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b' ||
12581        gameMode == BeginningOfGame || gameMode == MachinePlaysBlack)
12582         return &second;
12583     return &first;
12584 }
12585
12586 void
12587 SendTimeRemaining(cps, machineWhite)
12588      ChessProgramState *cps;
12589      int /*boolean*/ machineWhite;
12590 {
12591     char message[MSG_SIZ];
12592     long time, otime;
12593
12594     /* Note: this routine must be called when the clocks are stopped
12595        or when they have *just* been set or switched; otherwise
12596        it will be off by the time since the current tick started.
12597     */
12598     if (machineWhite) {
12599         time = whiteTimeRemaining / 10;
12600         otime = blackTimeRemaining / 10;
12601     } else {
12602         time = blackTimeRemaining / 10;
12603         otime = whiteTimeRemaining / 10;
12604     }
12605     /* [HGM] translate opponent's time by time-odds factor */
12606     otime = (otime * cps->other->timeOdds) / cps->timeOdds;
12607     if (appData.debugMode) {
12608         fprintf(debugFP, "time odds: %d %d \n", cps->timeOdds, cps->other->timeOdds);
12609     }
12610
12611     if (time <= 0) time = 1;
12612     if (otime <= 0) otime = 1;
12613
12614     sprintf(message, "time %ld\n", time);
12615     SendToProgram(message, cps);
12616
12617     sprintf(message, "otim %ld\n", otime);
12618     SendToProgram(message, cps);
12619 }
12620
12621 int
12622 BoolFeature(p, name, loc, cps)
12623      char **p;
12624      char *name;
12625      int *loc;
12626      ChessProgramState *cps;
12627 {
12628   char buf[MSG_SIZ];
12629   int len = strlen(name);
12630   int val;
12631   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
12632     (*p) += len + 1;
12633     sscanf(*p, "%d", &val);
12634     *loc = (val != 0);
12635     while (**p && **p != ' ') (*p)++;
12636     sprintf(buf, "accepted %s\n", name);
12637     SendToProgram(buf, cps);
12638     return TRUE;
12639   }
12640   return FALSE;
12641 }
12642
12643 int
12644 IntFeature(p, name, loc, cps)
12645      char **p;
12646      char *name;
12647      int *loc;
12648      ChessProgramState *cps;
12649 {
12650   char buf[MSG_SIZ];
12651   int len = strlen(name);
12652   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
12653     (*p) += len + 1;
12654     sscanf(*p, "%d", loc);
12655     while (**p && **p != ' ') (*p)++;
12656     sprintf(buf, "accepted %s\n", name);
12657     SendToProgram(buf, cps);
12658     return TRUE;
12659   }
12660   return FALSE;
12661 }
12662
12663 int
12664 StringFeature(p, name, loc, cps)
12665      char **p;
12666      char *name;
12667      char loc[];
12668      ChessProgramState *cps;
12669 {
12670   char buf[MSG_SIZ];
12671   int len = strlen(name);
12672   if (strncmp((*p), name, len) == 0
12673       && (*p)[len] == '=' && (*p)[len+1] == '\"') {
12674     (*p) += len + 2;
12675     sscanf(*p, "%[^\"]", loc);
12676     while (**p && **p != '\"') (*p)++;
12677     if (**p == '\"') (*p)++;
12678     sprintf(buf, "accepted %s\n", name);
12679     SendToProgram(buf, cps);
12680     return TRUE;
12681   }
12682   return FALSE;
12683 }
12684
12685 int
12686 ParseOption(Option *opt, ChessProgramState *cps)
12687 // [HGM] options: process the string that defines an engine option, and determine
12688 // name, type, default value, and allowed value range
12689 {
12690         char *p, *q, buf[MSG_SIZ];
12691         int n, min = (-1)<<31, max = 1<<31, def;
12692
12693         if(p = strstr(opt->name, " -spin ")) {
12694             if((n = sscanf(p, " -spin %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
12695             if(max < min) max = min; // enforce consistency
12696             if(def < min) def = min;
12697             if(def > max) def = max;
12698             opt->value = def;
12699             opt->min = min;
12700             opt->max = max;
12701             opt->type = Spin;
12702         } else if((p = strstr(opt->name, " -slider "))) {
12703             // for now -slider is a synonym for -spin, to already provide compatibility with future polyglots
12704             if((n = sscanf(p, " -slider %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
12705             if(max < min) max = min; // enforce consistency
12706             if(def < min) def = min;
12707             if(def > max) def = max;
12708             opt->value = def;
12709             opt->min = min;
12710             opt->max = max;
12711             opt->type = Spin; // Slider;
12712         } else if((p = strstr(opt->name, " -string "))) {
12713             opt->textValue = p+9;
12714             opt->type = TextBox;
12715         } else if((p = strstr(opt->name, " -file "))) {
12716             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
12717             opt->textValue = p+7;
12718             opt->type = TextBox; // FileName;
12719         } else if((p = strstr(opt->name, " -path "))) {
12720             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
12721             opt->textValue = p+7;
12722             opt->type = TextBox; // PathName;
12723         } else if(p = strstr(opt->name, " -check ")) {
12724             if(sscanf(p, " -check %d", &def) < 1) return FALSE;
12725             opt->value = (def != 0);
12726             opt->type = CheckBox;
12727         } else if(p = strstr(opt->name, " -combo ")) {
12728             opt->textValue = (char*) (&cps->comboList[cps->comboCnt]); // cheat with pointer type
12729             cps->comboList[cps->comboCnt++] = q = p+8; // holds possible choices
12730             if(*q == '*') cps->comboList[cps->comboCnt-1]++;
12731             opt->value = n = 0;
12732             while(q = StrStr(q, " /// ")) {
12733                 n++; *q = 0;    // count choices, and null-terminate each of them
12734                 q += 5;
12735                 if(*q == '*') { // remember default, which is marked with * prefix
12736                     q++;
12737                     opt->value = n;
12738                 }
12739                 cps->comboList[cps->comboCnt++] = q;
12740             }
12741             cps->comboList[cps->comboCnt++] = NULL;
12742             opt->max = n + 1;
12743             opt->type = ComboBox;
12744         } else if(p = strstr(opt->name, " -button")) {
12745             opt->type = Button;
12746         } else if(p = strstr(opt->name, " -save")) {
12747             opt->type = SaveButton;
12748         } else return FALSE;
12749         *p = 0; // terminate option name
12750         // now look if the command-line options define a setting for this engine option.
12751         if(cps->optionSettings && cps->optionSettings[0])
12752             p = strstr(cps->optionSettings, opt->name); else p = NULL;
12753         if(p && (p == cps->optionSettings || p[-1] == ',')) {
12754                 sprintf(buf, "option %s", p);
12755                 if(p = strstr(buf, ",")) *p = 0;
12756                 strcat(buf, "\n");
12757                 SendToProgram(buf, cps);
12758         }
12759         return TRUE;
12760 }
12761
12762 void
12763 FeatureDone(cps, val)
12764      ChessProgramState* cps;
12765      int val;
12766 {
12767   DelayedEventCallback cb = GetDelayedEvent();
12768   if ((cb == InitBackEnd3 && cps == &first) ||
12769       (cb == TwoMachinesEventIfReady && cps == &second)) {
12770     CancelDelayedEvent();
12771     ScheduleDelayedEvent(cb, val ? 1 : 3600000);
12772   }
12773   cps->initDone = val;
12774 }
12775
12776 /* Parse feature command from engine */
12777 void
12778 ParseFeatures(args, cps)
12779      char* args;
12780      ChessProgramState *cps;
12781 {
12782   char *p = args;
12783   char *q;
12784   int val;
12785   char buf[MSG_SIZ];
12786
12787   for (;;) {
12788     while (*p == ' ') p++;
12789     if (*p == NULLCHAR) return;
12790
12791     if (BoolFeature(&p, "setboard", &cps->useSetboard, cps)) continue;
12792     if (BoolFeature(&p, "time", &cps->sendTime, cps)) continue;
12793     if (BoolFeature(&p, "draw", &cps->sendDrawOffers, cps)) continue;
12794     if (BoolFeature(&p, "sigint", &cps->useSigint, cps)) continue;
12795     if (BoolFeature(&p, "sigterm", &cps->useSigterm, cps)) continue;
12796     if (BoolFeature(&p, "reuse", &val, cps)) {
12797       /* Engine can disable reuse, but can't enable it if user said no */
12798       if (!val) cps->reuse = FALSE;
12799       continue;
12800     }
12801     if (BoolFeature(&p, "analyze", &cps->analysisSupport, cps)) continue;
12802     if (StringFeature(&p, "myname", &cps->tidy, cps)) {
12803       if (gameMode == TwoMachinesPlay) {
12804         DisplayTwoMachinesTitle();
12805       } else {
12806         DisplayTitle("");
12807       }
12808       continue;
12809     }
12810     if (StringFeature(&p, "variants", &cps->variants, cps)) continue;
12811     if (BoolFeature(&p, "san", &cps->useSAN, cps)) continue;
12812     if (BoolFeature(&p, "ping", &cps->usePing, cps)) continue;
12813     if (BoolFeature(&p, "playother", &cps->usePlayother, cps)) continue;
12814     if (BoolFeature(&p, "colors", &cps->useColors, cps)) continue;
12815     if (BoolFeature(&p, "usermove", &cps->useUsermove, cps)) continue;
12816     if (BoolFeature(&p, "ics", &cps->sendICS, cps)) continue;
12817     if (BoolFeature(&p, "name", &cps->sendName, cps)) continue;
12818     if (BoolFeature(&p, "pause", &val, cps)) continue; /* unused at present */
12819     if (IntFeature(&p, "done", &val, cps)) {
12820       FeatureDone(cps, val);
12821       continue;
12822     }
12823     /* Added by Tord: */
12824     if (BoolFeature(&p, "fen960", &cps->useFEN960, cps)) continue;
12825     if (BoolFeature(&p, "oocastle", &cps->useOOCastle, cps)) continue;
12826     /* End of additions by Tord */
12827
12828     /* [HGM] added features: */
12829     if (BoolFeature(&p, "debug", &cps->debug, cps)) continue;
12830     if (BoolFeature(&p, "nps", &cps->supportsNPS, cps)) continue;
12831     if (IntFeature(&p, "level", &cps->maxNrOfSessions, cps)) continue;
12832     if (BoolFeature(&p, "memory", &cps->memSize, cps)) continue;
12833     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
12834     if (StringFeature(&p, "egt", &cps->egtFormats, cps)) continue;
12835     if (StringFeature(&p, "option", &(cps->option[cps->nrOptions].name), cps)) {
12836         if(!ParseOption(&(cps->option[cps->nrOptions++]), cps)) { // [HGM] options: add option feature
12837             sprintf(buf, "rejected option %s\n", cps->option[--cps->nrOptions].name);
12838             SendToProgram(buf, cps);
12839             continue;
12840         }
12841         if(cps->nrOptions >= MAX_OPTIONS) {
12842             cps->nrOptions--;
12843             sprintf(buf, "%s engine has too many options\n", cps->which);
12844             DisplayError(buf, 0);
12845         }
12846         continue;
12847     }
12848     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
12849     /* End of additions by HGM */
12850
12851     /* unknown feature: complain and skip */
12852     q = p;
12853     while (*q && *q != '=') q++;
12854     sprintf(buf, "rejected %.*s\n", (int)(q-p), p);
12855     SendToProgram(buf, cps);
12856     p = q;
12857     if (*p == '=') {
12858       p++;
12859       if (*p == '\"') {
12860         p++;
12861         while (*p && *p != '\"') p++;
12862         if (*p == '\"') p++;
12863       } else {
12864         while (*p && *p != ' ') p++;
12865       }
12866     }
12867   }
12868
12869 }
12870
12871 void
12872 PeriodicUpdatesEvent(newState)
12873      int newState;
12874 {
12875     if (newState == appData.periodicUpdates)
12876       return;
12877
12878     appData.periodicUpdates=newState;
12879
12880     /* Display type changes, so update it now */
12881 //    DisplayAnalysis();
12882
12883     /* Get the ball rolling again... */
12884     if (newState) {
12885         AnalysisPeriodicEvent(1);
12886         StartAnalysisClock();
12887     }
12888 }
12889
12890 void
12891 PonderNextMoveEvent(newState)
12892      int newState;
12893 {
12894     if (newState == appData.ponderNextMove) return;
12895     if (gameMode == EditPosition) EditPositionDone(TRUE);
12896     if (newState) {
12897         SendToProgram("hard\n", &first);
12898         if (gameMode == TwoMachinesPlay) {
12899             SendToProgram("hard\n", &second);
12900         }
12901     } else {
12902         SendToProgram("easy\n", &first);
12903         thinkOutput[0] = NULLCHAR;
12904         if (gameMode == TwoMachinesPlay) {
12905             SendToProgram("easy\n", &second);
12906         }
12907     }
12908     appData.ponderNextMove = newState;
12909 }
12910
12911 void
12912 NewSettingEvent(option, command, value)
12913      char *command;
12914      int option, value;
12915 {
12916     char buf[MSG_SIZ];
12917
12918     if (gameMode == EditPosition) EditPositionDone(TRUE);
12919     sprintf(buf, "%s%s %d\n", (option ? "option ": ""), command, value);
12920     SendToProgram(buf, &first);
12921     if (gameMode == TwoMachinesPlay) {
12922         SendToProgram(buf, &second);
12923     }
12924 }
12925
12926 void
12927 ShowThinkingEvent()
12928 // [HGM] thinking: this routine is now also called from "Options -> Engine..." popup
12929 {
12930     static int oldState = 2; // kludge alert! Neither true nor fals, so first time oldState is always updated
12931     int newState = appData.showThinking
12932         // [HGM] thinking: other features now need thinking output as well
12933         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp();
12934
12935     if (oldState == newState) return;
12936     oldState = newState;
12937     if (gameMode == EditPosition) EditPositionDone(TRUE);
12938     if (oldState) {
12939         SendToProgram("post\n", &first);
12940         if (gameMode == TwoMachinesPlay) {
12941             SendToProgram("post\n", &second);
12942         }
12943     } else {
12944         SendToProgram("nopost\n", &first);
12945         thinkOutput[0] = NULLCHAR;
12946         if (gameMode == TwoMachinesPlay) {
12947             SendToProgram("nopost\n", &second);
12948         }
12949     }
12950 //    appData.showThinking = newState; // [HGM] thinking: responsible option should already have be changed when calling this routine!
12951 }
12952
12953 void
12954 AskQuestionEvent(title, question, replyPrefix, which)
12955      char *title; char *question; char *replyPrefix; char *which;
12956 {
12957   ProcRef pr = (which[0] == '1') ? first.pr : second.pr;
12958   if (pr == NoProc) return;
12959   AskQuestion(title, question, replyPrefix, pr);
12960 }
12961
12962 void
12963 DisplayMove(moveNumber)
12964      int moveNumber;
12965 {
12966     char message[MSG_SIZ];
12967     char res[MSG_SIZ];
12968     char cpThinkOutput[MSG_SIZ];
12969
12970     if(appData.noGUI) return; // [HGM] fast: suppress display of moves
12971
12972     if (moveNumber == forwardMostMove - 1 ||
12973         gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12974
12975         safeStrCpy(cpThinkOutput, thinkOutput, sizeof(cpThinkOutput));
12976
12977         if (strchr(cpThinkOutput, '\n')) {
12978             *strchr(cpThinkOutput, '\n') = NULLCHAR;
12979         }
12980     } else {
12981         *cpThinkOutput = NULLCHAR;
12982     }
12983
12984     /* [AS] Hide thinking from human user */
12985     if( appData.hideThinkingFromHuman && gameMode != TwoMachinesPlay ) {
12986         *cpThinkOutput = NULLCHAR;
12987         if( thinkOutput[0] != NULLCHAR ) {
12988             int i;
12989
12990             for( i=0; i<=hiddenThinkOutputState; i++ ) {
12991                 cpThinkOutput[i] = '.';
12992             }
12993             cpThinkOutput[i] = NULLCHAR;
12994             hiddenThinkOutputState = (hiddenThinkOutputState + 1) % 3;
12995         }
12996     }
12997
12998     if (moveNumber == forwardMostMove - 1 &&
12999         gameInfo.resultDetails != NULL) {
13000         if (gameInfo.resultDetails[0] == NULLCHAR) {
13001             sprintf(res, " %s", PGNResult(gameInfo.result));
13002         } else {
13003             sprintf(res, " {%s} %s",
13004                     gameInfo.resultDetails, PGNResult(gameInfo.result));
13005         }
13006     } else {
13007         res[0] = NULLCHAR;
13008     }
13009
13010     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
13011         DisplayMessage(res, cpThinkOutput);
13012     } else {
13013         sprintf(message, "%d.%s%s%s", moveNumber / 2 + 1,
13014                 WhiteOnMove(moveNumber) ? " " : ".. ",
13015                 parseList[moveNumber], res);
13016         DisplayMessage(message, cpThinkOutput);
13017     }
13018 }
13019
13020 void
13021 DisplayComment(moveNumber, text)
13022      int moveNumber;
13023      char *text;
13024 {
13025     char title[MSG_SIZ];
13026     char buf[8000]; // comment can be long!
13027     int score, depth;
13028
13029     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
13030       strcpy(title, "Comment");
13031     } else {
13032       sprintf(title, "Comment on %d.%s%s", moveNumber / 2 + 1,
13033               WhiteOnMove(moveNumber) ? " " : ".. ",
13034               parseList[moveNumber]);
13035     }
13036     // [HGM] PV info: display PV info together with (or as) comment
13037     if(moveNumber >= 0 && (depth = pvInfoList[moveNumber].depth) > 0) {
13038       if(text == NULL) text = "";
13039       score = pvInfoList[moveNumber].score;
13040       sprintf(buf, "%s%.2f/%d %d\n%s", score>0 ? "+" : "", score/100.,
13041               depth, (pvInfoList[moveNumber].time+50)/100, text);
13042       text = buf;
13043     }
13044     if (text != NULL && (appData.autoDisplayComment || commentUp))
13045         CommentPopUp(title, text);
13046 }
13047
13048 /* This routine sends a ^C interrupt to gnuchess, to awaken it if it
13049  * might be busy thinking or pondering.  It can be omitted if your
13050  * gnuchess is configured to stop thinking immediately on any user
13051  * input.  However, that gnuchess feature depends on the FIONREAD
13052  * ioctl, which does not work properly on some flavors of Unix.
13053  */
13054 void
13055 Attention(cps)
13056      ChessProgramState *cps;
13057 {
13058 #if ATTENTION
13059     if (!cps->useSigint) return;
13060     if (appData.noChessProgram || (cps->pr == NoProc)) return;
13061     switch (gameMode) {
13062       case MachinePlaysWhite:
13063       case MachinePlaysBlack:
13064       case TwoMachinesPlay:
13065       case IcsPlayingWhite:
13066       case IcsPlayingBlack:
13067       case AnalyzeMode:
13068       case AnalyzeFile:
13069         /* Skip if we know it isn't thinking */
13070         if (!cps->maybeThinking) return;
13071         if (appData.debugMode)
13072           fprintf(debugFP, "Interrupting %s\n", cps->which);
13073         InterruptChildProcess(cps->pr);
13074         cps->maybeThinking = FALSE;
13075         break;
13076       default:
13077         break;
13078     }
13079 #endif /*ATTENTION*/
13080 }
13081
13082 int
13083 CheckFlags()
13084 {
13085     if (whiteTimeRemaining <= 0) {
13086         if (!whiteFlag) {
13087             whiteFlag = TRUE;
13088             if (appData.icsActive) {
13089                 if (appData.autoCallFlag &&
13090                     gameMode == IcsPlayingBlack && !blackFlag) {
13091                   SendToICS(ics_prefix);
13092                   SendToICS("flag\n");
13093                 }
13094             } else {
13095                 if (blackFlag) {
13096                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
13097                 } else {
13098                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("White's flag fell"));
13099                     if (appData.autoCallFlag) {
13100                         GameEnds(BlackWins, "Black wins on time", GE_XBOARD);
13101                         return TRUE;
13102                     }
13103                 }
13104             }
13105         }
13106     }
13107     if (blackTimeRemaining <= 0) {
13108         if (!blackFlag) {
13109             blackFlag = TRUE;
13110             if (appData.icsActive) {
13111                 if (appData.autoCallFlag &&
13112                     gameMode == IcsPlayingWhite && !whiteFlag) {
13113                   SendToICS(ics_prefix);
13114                   SendToICS("flag\n");
13115                 }
13116             } else {
13117                 if (whiteFlag) {
13118                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
13119                 } else {
13120                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Black's flag fell"));
13121                     if (appData.autoCallFlag) {
13122                         GameEnds(WhiteWins, "White wins on time", GE_XBOARD);
13123                         return TRUE;
13124                     }
13125                 }
13126             }
13127         }
13128     }
13129     return FALSE;
13130 }
13131
13132 void
13133 CheckTimeControl()
13134 {
13135     if (!appData.clockMode || appData.icsActive ||
13136         gameMode == PlayFromGameFile || forwardMostMove == 0) return;
13137
13138     /*
13139      * add time to clocks when time control is achieved ([HGM] now also used for increment)
13140      */
13141     if ( !WhiteOnMove(forwardMostMove) )
13142         /* White made time control */
13143         whiteTimeRemaining += GetTimeQuota((forwardMostMove-1)/2)
13144         /* [HGM] time odds: correct new time quota for time odds! */
13145                                             / WhitePlayer()->timeOdds;
13146       else
13147         /* Black made time control */
13148         blackTimeRemaining += GetTimeQuota((forwardMostMove-1)/2)
13149                                             / WhitePlayer()->other->timeOdds;
13150 }
13151
13152 void
13153 DisplayBothClocks()
13154 {
13155     int wom = gameMode == EditPosition ?
13156       !blackPlaysFirst : WhiteOnMove(currentMove);
13157     DisplayWhiteClock(whiteTimeRemaining, wom);
13158     DisplayBlackClock(blackTimeRemaining, !wom);
13159 }
13160
13161
13162 /* Timekeeping seems to be a portability nightmare.  I think everyone
13163    has ftime(), but I'm really not sure, so I'm including some ifdefs
13164    to use other calls if you don't.  Clocks will be less accurate if
13165    you have neither ftime nor gettimeofday.
13166 */
13167
13168 /* VS 2008 requires the #include outside of the function */
13169 #if !HAVE_GETTIMEOFDAY && HAVE_FTIME
13170 #include <sys/timeb.h>
13171 #endif
13172
13173 /* Get the current time as a TimeMark */
13174 void
13175 GetTimeMark(tm)
13176      TimeMark *tm;
13177 {
13178 #if HAVE_GETTIMEOFDAY
13179
13180     struct timeval timeVal;
13181     struct timezone timeZone;
13182
13183     gettimeofday(&timeVal, &timeZone);
13184     tm->sec = (long) timeVal.tv_sec;
13185     tm->ms = (int) (timeVal.tv_usec / 1000L);
13186
13187 #else /*!HAVE_GETTIMEOFDAY*/
13188 #if HAVE_FTIME
13189
13190 // include <sys/timeb.h> / moved to just above start of function
13191     struct timeb timeB;
13192
13193     ftime(&timeB);
13194     tm->sec = (long) timeB.time;
13195     tm->ms = (int) timeB.millitm;
13196
13197 #else /*!HAVE_FTIME && !HAVE_GETTIMEOFDAY*/
13198     tm->sec = (long) time(NULL);
13199     tm->ms = 0;
13200 #endif
13201 #endif
13202 }
13203
13204 /* Return the difference in milliseconds between two
13205    time marks.  We assume the difference will fit in a long!
13206 */
13207 long
13208 SubtractTimeMarks(tm2, tm1)
13209      TimeMark *tm2, *tm1;
13210 {
13211     return 1000L*(tm2->sec - tm1->sec) +
13212            (long) (tm2->ms - tm1->ms);
13213 }
13214
13215
13216 /*
13217  * Code to manage the game clocks.
13218  *
13219  * In tournament play, black starts the clock and then white makes a move.
13220  * We give the human user a slight advantage if he is playing white---the
13221  * clocks don't run until he makes his first move, so it takes zero time.
13222  * Also, we don't account for network lag, so we could get out of sync
13223  * with GNU Chess's clock -- but then, referees are always right.
13224  */
13225
13226 static TimeMark tickStartTM;
13227 static long intendedTickLength;
13228
13229 long
13230 NextTickLength(timeRemaining)
13231      long timeRemaining;
13232 {
13233     long nominalTickLength, nextTickLength;
13234
13235     if (timeRemaining > 0L && timeRemaining <= 10000L)
13236       nominalTickLength = 100L;
13237     else
13238       nominalTickLength = 1000L;
13239     nextTickLength = timeRemaining % nominalTickLength;
13240     if (nextTickLength <= 0) nextTickLength += nominalTickLength;
13241
13242     return nextTickLength;
13243 }
13244
13245 /* Adjust clock one minute up or down */
13246 void
13247 AdjustClock(Boolean which, int dir)
13248 {
13249     if(which) blackTimeRemaining += 60000*dir;
13250     else      whiteTimeRemaining += 60000*dir;
13251     DisplayBothClocks();
13252 }
13253
13254 /* Stop clocks and reset to a fresh time control */
13255 void
13256 ResetClocks()
13257 {
13258     (void) StopClockTimer();
13259     if (appData.icsActive) {
13260         whiteTimeRemaining = blackTimeRemaining = 0;
13261     } else { /* [HGM] correct new time quote for time odds */
13262         whiteTimeRemaining = GetTimeQuota(-1) / WhitePlayer()->timeOdds;
13263         blackTimeRemaining = GetTimeQuota(-1) / WhitePlayer()->other->timeOdds;
13264     }
13265     if (whiteFlag || blackFlag) {
13266         DisplayTitle("");
13267         whiteFlag = blackFlag = FALSE;
13268     }
13269     DisplayBothClocks();
13270 }
13271
13272 #define FUDGE 25 /* 25ms = 1/40 sec; should be plenty even for 50 Hz clocks */
13273
13274 /* Decrement running clock by amount of time that has passed */
13275 void
13276 DecrementClocks()
13277 {
13278     long timeRemaining;
13279     long lastTickLength, fudge;
13280     TimeMark now;
13281
13282     if (!appData.clockMode) return;
13283     if (gameMode==AnalyzeMode || gameMode == AnalyzeFile) return;
13284
13285     GetTimeMark(&now);
13286
13287     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
13288
13289     /* Fudge if we woke up a little too soon */
13290     fudge = intendedTickLength - lastTickLength;
13291     if (fudge < 0 || fudge > FUDGE) fudge = 0;
13292
13293     if (WhiteOnMove(forwardMostMove)) {
13294         if(whiteNPS >= 0) lastTickLength = 0;
13295         timeRemaining = whiteTimeRemaining -= lastTickLength;
13296         DisplayWhiteClock(whiteTimeRemaining - fudge,
13297                           WhiteOnMove(currentMove));
13298     } else {
13299         if(blackNPS >= 0) lastTickLength = 0;
13300         timeRemaining = blackTimeRemaining -= lastTickLength;
13301         DisplayBlackClock(blackTimeRemaining - fudge,
13302                           !WhiteOnMove(currentMove));
13303     }
13304
13305     if (CheckFlags()) return;
13306
13307     tickStartTM = now;
13308     intendedTickLength = NextTickLength(timeRemaining - fudge) + fudge;
13309     StartClockTimer(intendedTickLength);
13310
13311     /* if the time remaining has fallen below the alarm threshold, sound the
13312      * alarm. if the alarm has sounded and (due to a takeback or time control
13313      * with increment) the time remaining has increased to a level above the
13314      * threshold, reset the alarm so it can sound again.
13315      */
13316
13317     if (appData.icsActive && appData.icsAlarm) {
13318
13319         /* make sure we are dealing with the user's clock */
13320         if (!( ((gameMode == IcsPlayingWhite) && WhiteOnMove(currentMove)) ||
13321                ((gameMode == IcsPlayingBlack) && !WhiteOnMove(currentMove))
13322            )) return;
13323
13324         if (alarmSounded && (timeRemaining > appData.icsAlarmTime)) {
13325             alarmSounded = FALSE;
13326         } else if (!alarmSounded && (timeRemaining <= appData.icsAlarmTime)) {
13327             PlayAlarmSound();
13328             alarmSounded = TRUE;
13329         }
13330     }
13331 }
13332
13333
13334 /* A player has just moved, so stop the previously running
13335    clock and (if in clock mode) start the other one.
13336    We redisplay both clocks in case we're in ICS mode, because
13337    ICS gives us an update to both clocks after every move.
13338    Note that this routine is called *after* forwardMostMove
13339    is updated, so the last fractional tick must be subtracted
13340    from the color that is *not* on move now.
13341 */
13342 void
13343 SwitchClocks()
13344 {
13345     long lastTickLength;
13346     TimeMark now;
13347     int flagged = FALSE;
13348
13349     GetTimeMark(&now);
13350
13351     if (StopClockTimer() && appData.clockMode) {
13352         lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
13353         if (WhiteOnMove(forwardMostMove)) {
13354             if(blackNPS >= 0) lastTickLength = 0;
13355             blackTimeRemaining -= lastTickLength;
13356            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
13357 //         if(pvInfoList[forwardMostMove-1].time == -1)
13358                  pvInfoList[forwardMostMove-1].time =               // use GUI time
13359                       (timeRemaining[1][forwardMostMove-1] - blackTimeRemaining)/10;
13360         } else {
13361            if(whiteNPS >= 0) lastTickLength = 0;
13362            whiteTimeRemaining -= lastTickLength;
13363            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
13364 //         if(pvInfoList[forwardMostMove-1].time == -1)
13365                  pvInfoList[forwardMostMove-1].time =
13366                       (timeRemaining[0][forwardMostMove-1] - whiteTimeRemaining)/10;
13367         }
13368         flagged = CheckFlags();
13369     }
13370     CheckTimeControl();
13371
13372     if (flagged || !appData.clockMode) return;
13373
13374     switch (gameMode) {
13375       case MachinePlaysBlack:
13376       case MachinePlaysWhite:
13377       case BeginningOfGame:
13378         if (pausing) return;
13379         break;
13380
13381       case EditGame:
13382       case PlayFromGameFile:
13383       case IcsExamining:
13384         return;
13385
13386       default:
13387         break;
13388     }
13389
13390     tickStartTM = now;
13391     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
13392       whiteTimeRemaining : blackTimeRemaining);
13393     StartClockTimer(intendedTickLength);
13394 }
13395
13396
13397 /* Stop both clocks */
13398 void
13399 StopClocks()
13400 {
13401     long lastTickLength;
13402     TimeMark now;
13403
13404     if (!StopClockTimer()) return;
13405     if (!appData.clockMode) return;
13406
13407     GetTimeMark(&now);
13408
13409     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
13410     if (WhiteOnMove(forwardMostMove)) {
13411         if(whiteNPS >= 0) lastTickLength = 0;
13412         whiteTimeRemaining -= lastTickLength;
13413         DisplayWhiteClock(whiteTimeRemaining, WhiteOnMove(currentMove));
13414     } else {
13415         if(blackNPS >= 0) lastTickLength = 0;
13416         blackTimeRemaining -= lastTickLength;
13417         DisplayBlackClock(blackTimeRemaining, !WhiteOnMove(currentMove));
13418     }
13419     CheckFlags();
13420 }
13421
13422 /* Start clock of player on move.  Time may have been reset, so
13423    if clock is already running, stop and restart it. */
13424 void
13425 StartClocks()
13426 {
13427     (void) StopClockTimer(); /* in case it was running already */
13428     DisplayBothClocks();
13429     if (CheckFlags()) return;
13430
13431     if (!appData.clockMode) return;
13432     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) return;
13433
13434     GetTimeMark(&tickStartTM);
13435     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
13436       whiteTimeRemaining : blackTimeRemaining);
13437
13438    /* [HGM] nps: figure out nps factors, by determining which engine plays white and/or black once and for all */
13439     whiteNPS = blackNPS = -1;
13440     if(gameMode == MachinePlaysWhite || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w'
13441        || appData.zippyPlay && gameMode == IcsPlayingBlack) // first (perhaps only) engine has white
13442         whiteNPS = first.nps;
13443     if(gameMode == MachinePlaysBlack || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b'
13444        || appData.zippyPlay && gameMode == IcsPlayingWhite) // first (perhaps only) engine has black
13445         blackNPS = first.nps;
13446     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b') // second only used in Two-Machines mode
13447         whiteNPS = second.nps;
13448     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w')
13449         blackNPS = second.nps;
13450     if(appData.debugMode) fprintf(debugFP, "nps: w=%d, b=%d\n", whiteNPS, blackNPS);
13451
13452     StartClockTimer(intendedTickLength);
13453 }
13454
13455 char *
13456 TimeString(ms)
13457      long ms;
13458 {
13459     long second, minute, hour, day;
13460     char *sign = "";
13461     static char buf[32];
13462
13463     if (ms > 0 && ms <= 9900) {
13464       /* convert milliseconds to tenths, rounding up */
13465       double tenths = floor( ((double)(ms + 99L)) / 100.00 );
13466
13467       sprintf(buf, " %03.1f ", tenths/10.0);
13468       return buf;
13469     }
13470
13471     /* convert milliseconds to seconds, rounding up */
13472     /* use floating point to avoid strangeness of integer division
13473        with negative dividends on many machines */
13474     second = (long) floor(((double) (ms + 999L)) / 1000.0);
13475
13476     if (second < 0) {
13477         sign = "-";
13478         second = -second;
13479     }
13480
13481     day = second / (60 * 60 * 24);
13482     second = second % (60 * 60 * 24);
13483     hour = second / (60 * 60);
13484     second = second % (60 * 60);
13485     minute = second / 60;
13486     second = second % 60;
13487
13488     if (day > 0)
13489       sprintf(buf, " %s%ld:%02ld:%02ld:%02ld ",
13490               sign, day, hour, minute, second);
13491     else if (hour > 0)
13492       sprintf(buf, " %s%ld:%02ld:%02ld ", sign, hour, minute, second);
13493     else
13494       sprintf(buf, " %s%2ld:%02ld ", sign, minute, second);
13495
13496     return buf;
13497 }
13498
13499
13500 /*
13501  * This is necessary because some C libraries aren't ANSI C compliant yet.
13502  */
13503 char *
13504 StrStr(string, match)
13505      char *string, *match;
13506 {
13507     int i, length;
13508
13509     length = strlen(match);
13510
13511     for (i = strlen(string) - length; i >= 0; i--, string++)
13512       if (!strncmp(match, string, length))
13513         return string;
13514
13515     return NULL;
13516 }
13517
13518 char *
13519 StrCaseStr(string, match)
13520      char *string, *match;
13521 {
13522     int i, j, length;
13523
13524     length = strlen(match);
13525
13526     for (i = strlen(string) - length; i >= 0; i--, string++) {
13527         for (j = 0; j < length; j++) {
13528             if (ToLower(match[j]) != ToLower(string[j]))
13529               break;
13530         }
13531         if (j == length) return string;
13532     }
13533
13534     return NULL;
13535 }
13536
13537 #ifndef _amigados
13538 int
13539 StrCaseCmp(s1, s2)
13540      char *s1, *s2;
13541 {
13542     char c1, c2;
13543
13544     for (;;) {
13545         c1 = ToLower(*s1++);
13546         c2 = ToLower(*s2++);
13547         if (c1 > c2) return 1;
13548         if (c1 < c2) return -1;
13549         if (c1 == NULLCHAR) return 0;
13550     }
13551 }
13552
13553
13554 int
13555 ToLower(c)
13556      int c;
13557 {
13558     return isupper(c) ? tolower(c) : c;
13559 }
13560
13561
13562 int
13563 ToUpper(c)
13564      int c;
13565 {
13566     return islower(c) ? toupper(c) : c;
13567 }
13568 #endif /* !_amigados    */
13569
13570 char *
13571 StrSave(s)
13572      char *s;
13573 {
13574     char *ret;
13575
13576     if ((ret = (char *) malloc(strlen(s) + 1))) {
13577         strcpy(ret, s);
13578     }
13579     return ret;
13580 }
13581
13582 char *
13583 StrSavePtr(s, savePtr)
13584      char *s, **savePtr;
13585 {
13586     if (*savePtr) {
13587         free(*savePtr);
13588     }
13589     if ((*savePtr = (char *) malloc(strlen(s) + 1))) {
13590         strcpy(*savePtr, s);
13591     }
13592     return(*savePtr);
13593 }
13594
13595 char *
13596 PGNDate()
13597 {
13598     time_t clock;
13599     struct tm *tm;
13600     char buf[MSG_SIZ];
13601
13602     clock = time((time_t *)NULL);
13603     tm = localtime(&clock);
13604     sprintf(buf, "%04d.%02d.%02d",
13605             tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
13606     return StrSave(buf);
13607 }
13608
13609
13610 char *
13611 PositionToFEN(move, overrideCastling)
13612      int move;
13613      char *overrideCastling;
13614 {
13615     int i, j, fromX, fromY, toX, toY;
13616     int whiteToPlay;
13617     char buf[128];
13618     char *p, *q;
13619     int emptycount;
13620     ChessSquare piece;
13621
13622     whiteToPlay = (gameMode == EditPosition) ?
13623       !blackPlaysFirst : (move % 2 == 0);
13624     p = buf;
13625
13626     /* Piece placement data */
13627     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
13628         emptycount = 0;
13629         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
13630             if (boards[move][i][j] == EmptySquare) {
13631                 emptycount++;
13632             } else { ChessSquare piece = boards[move][i][j];
13633                 if (emptycount > 0) {
13634                     if(emptycount<10) /* [HGM] can be >= 10 */
13635                         *p++ = '0' + emptycount;
13636                     else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
13637                     emptycount = 0;
13638                 }
13639                 if(PieceToChar(piece) == '+') {
13640                     /* [HGM] write promoted pieces as '+<unpromoted>' (Shogi) */
13641                     *p++ = '+';
13642                     piece = (ChessSquare)(DEMOTED piece);
13643                 }
13644                 *p++ = PieceToChar(piece);
13645                 if(p[-1] == '~') {
13646                     /* [HGM] flag promoted pieces as '<promoted>~' (Crazyhouse) */
13647                     p[-1] = PieceToChar((ChessSquare)(DEMOTED piece));
13648                     *p++ = '~';
13649                 }
13650             }
13651         }
13652         if (emptycount > 0) {
13653             if(emptycount<10) /* [HGM] can be >= 10 */
13654                 *p++ = '0' + emptycount;
13655             else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
13656             emptycount = 0;
13657         }
13658         *p++ = '/';
13659     }
13660     *(p - 1) = ' ';
13661
13662     /* [HGM] print Crazyhouse or Shogi holdings */
13663     if( gameInfo.holdingsWidth ) {
13664         *(p-1) = '['; /* if we wanted to support BFEN, this could be '/' */
13665         q = p;
13666         for(i=0; i<gameInfo.holdingsSize; i++) { /* white holdings */
13667             piece = boards[move][i][BOARD_WIDTH-1];
13668             if( piece != EmptySquare )
13669               for(j=0; j<(int) boards[move][i][BOARD_WIDTH-2]; j++)
13670                   *p++ = PieceToChar(piece);
13671         }
13672         for(i=0; i<gameInfo.holdingsSize; i++) { /* black holdings */
13673             piece = boards[move][BOARD_HEIGHT-i-1][0];
13674             if( piece != EmptySquare )
13675               for(j=0; j<(int) boards[move][BOARD_HEIGHT-i-1][1]; j++)
13676                   *p++ = PieceToChar(piece);
13677         }
13678
13679         if( q == p ) *p++ = '-';
13680         *p++ = ']';
13681         *p++ = ' ';
13682     }
13683
13684     /* Active color */
13685     *p++ = whiteToPlay ? 'w' : 'b';
13686     *p++ = ' ';
13687
13688   if(q = overrideCastling) { // [HGM] FRC: override castling & e.p fields for non-compliant engines
13689     while(*p++ = *q++); if(q != overrideCastling+1) p[-1] = ' ';
13690   } else {
13691   if(nrCastlingRights) {
13692      q = p;
13693      if(gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) {
13694        /* [HGM] write directly from rights */
13695            if(castlingRights[move][2] >= 0 &&
13696               castlingRights[move][0] >= 0   )
13697                 *p++ = castlingRights[move][0] + AAA + 'A' - 'a';
13698            if(castlingRights[move][2] >= 0 &&
13699               castlingRights[move][1] >= 0   )
13700                 *p++ = castlingRights[move][1] + AAA + 'A' - 'a';
13701            if(castlingRights[move][5] >= 0 &&
13702               castlingRights[move][3] >= 0   )
13703                 *p++ = castlingRights[move][3] + AAA;
13704            if(castlingRights[move][5] >= 0 &&
13705               castlingRights[move][4] >= 0   )
13706                 *p++ = castlingRights[move][4] + AAA;
13707      } else {
13708
13709         /* [HGM] write true castling rights */
13710         if( nrCastlingRights == 6 ) {
13711             if(castlingRights[move][0] == BOARD_RGHT-1 &&
13712                castlingRights[move][2] >= 0  ) *p++ = 'K';
13713             if(castlingRights[move][1] == BOARD_LEFT &&
13714                castlingRights[move][2] >= 0  ) *p++ = 'Q';
13715             if(castlingRights[move][3] == BOARD_RGHT-1 &&
13716                castlingRights[move][5] >= 0  ) *p++ = 'k';
13717             if(castlingRights[move][4] == BOARD_LEFT &&
13718                castlingRights[move][5] >= 0  ) *p++ = 'q';
13719         }
13720      }
13721      if (q == p) *p++ = '-'; /* No castling rights */
13722      *p++ = ' ';
13723   }
13724
13725   if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
13726      gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier ) {
13727     /* En passant target square */
13728     if (move > backwardMostMove) {
13729         fromX = moveList[move - 1][0] - AAA;
13730         fromY = moveList[move - 1][1] - ONE;
13731         toX = moveList[move - 1][2] - AAA;
13732         toY = moveList[move - 1][3] - ONE;
13733         if (fromY == (whiteToPlay ? BOARD_HEIGHT-2 : 1) &&
13734             toY == (whiteToPlay ? BOARD_HEIGHT-4 : 3) &&
13735             boards[move][toY][toX] == (whiteToPlay ? BlackPawn : WhitePawn) &&
13736             fromX == toX) {
13737             /* 2-square pawn move just happened */
13738             *p++ = toX + AAA;
13739             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
13740         } else {
13741             *p++ = '-';
13742         }
13743     } else if(move == backwardMostMove) {
13744         // [HGM] perhaps we should always do it like this, and forget the above?
13745         if(epStatus[move] >= 0) {
13746             *p++ = epStatus[move] + AAA;
13747             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
13748         } else {
13749             *p++ = '-';
13750         }
13751     } else {
13752         *p++ = '-';
13753     }
13754     *p++ = ' ';
13755   }
13756   }
13757
13758     /* [HGM] find reversible plies */
13759     {   int i = 0, j=move;
13760
13761         if (appData.debugMode) { int k;
13762             fprintf(debugFP, "write FEN 50-move: %d %d %d\n", initialRulePlies, forwardMostMove, backwardMostMove);
13763             for(k=backwardMostMove; k<=forwardMostMove; k++)
13764                 fprintf(debugFP, "e%d. p=%d\n", k, epStatus[k]);
13765
13766         }
13767
13768         while(j > backwardMostMove && epStatus[j] <= EP_NONE) j--,i++;
13769         if( j == backwardMostMove ) i += initialRulePlies;
13770         sprintf(p, "%d ", i);
13771         p += i>=100 ? 4 : i >= 10 ? 3 : 2;
13772     }
13773     /* Fullmove number */
13774     sprintf(p, "%d", (move / 2) + 1);
13775
13776     return StrSave(buf);
13777 }
13778
13779 Boolean
13780 ParseFEN(board, blackPlaysFirst, fen)
13781     Board board;
13782      int *blackPlaysFirst;
13783      char *fen;
13784 {
13785     int i, j;
13786     char *p;
13787     int emptycount;
13788     ChessSquare piece;
13789
13790     p = fen;
13791
13792     /* [HGM] by default clear Crazyhouse holdings, if present */
13793     if(gameInfo.holdingsWidth) {
13794        for(i=0; i<BOARD_HEIGHT; i++) {
13795            board[i][0]             = EmptySquare; /* black holdings */
13796            board[i][BOARD_WIDTH-1] = EmptySquare; /* white holdings */
13797            board[i][1]             = (ChessSquare) 0; /* black counts */
13798            board[i][BOARD_WIDTH-2] = (ChessSquare) 0; /* white counts */
13799        }
13800     }
13801
13802     /* Piece placement data */
13803     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
13804         j = 0;
13805         for (;;) {
13806             if (*p == '/' || *p == ' ' || (*p == '[' && i == 0) ) {
13807                 if (*p == '/') p++;
13808                 emptycount = gameInfo.boardWidth - j;
13809                 while (emptycount--)
13810                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
13811                 break;
13812 #if(BOARD_SIZE >= 10)
13813             } else if(*p=='x' || *p=='X') { /* [HGM] X means 10 */
13814                 p++; emptycount=10;
13815                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
13816                 while (emptycount--)
13817                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
13818 #endif
13819             } else if (isdigit(*p)) {
13820                 emptycount = *p++ - '0';
13821                 while(isdigit(*p)) emptycount = 10*emptycount + *p++ - '0'; /* [HGM] allow > 9 */
13822                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
13823                 while (emptycount--)
13824                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
13825             } else if (*p == '+' || isalpha(*p)) {
13826                 if (j >= gameInfo.boardWidth) return FALSE;
13827                 if(*p=='+') {
13828                     piece = CharToPiece(*++p);
13829                     if(piece == EmptySquare) return FALSE; /* unknown piece */
13830                     piece = (ChessSquare) (PROMOTED piece ); p++;
13831                     if(PieceToChar(piece) != '+') return FALSE; /* unpromotable piece */
13832                 } else piece = CharToPiece(*p++);
13833
13834                 if(piece==EmptySquare) return FALSE; /* unknown piece */
13835                 if(*p == '~') { /* [HGM] make it a promoted piece for Crazyhouse */
13836                     piece = (ChessSquare) (PROMOTED piece);
13837                     if(PieceToChar(piece) != '~') return FALSE; /* cannot be a promoted piece */
13838                     p++;
13839                 }
13840                 board[i][(j++)+gameInfo.holdingsWidth] = piece;
13841             } else {
13842                 return FALSE;
13843             }
13844         }
13845     }
13846     while (*p == '/' || *p == ' ') p++;
13847
13848     /* [HGM] look for Crazyhouse holdings here */
13849     while(*p==' ') p++;
13850     if( gameInfo.holdingsWidth && p[-1] == '/' || *p == '[') {
13851         if(*p == '[') p++;
13852         if(*p == '-' ) *p++; /* empty holdings */ else {
13853             if( !gameInfo.holdingsWidth ) return FALSE; /* no room to put holdings! */
13854             /* if we would allow FEN reading to set board size, we would   */
13855             /* have to add holdings and shift the board read so far here   */
13856             while( (piece = CharToPiece(*p) ) != EmptySquare ) {
13857                 *p++;
13858                 if((int) piece >= (int) BlackPawn ) {
13859                     i = (int)piece - (int)BlackPawn;
13860                     i = PieceToNumber((ChessSquare)i);
13861                     if( i >= gameInfo.holdingsSize ) return FALSE;
13862                     board[BOARD_HEIGHT-1-i][0] = piece; /* black holdings */
13863                     board[BOARD_HEIGHT-1-i][1]++;       /* black counts   */
13864                 } else {
13865                     i = (int)piece - (int)WhitePawn;
13866                     i = PieceToNumber((ChessSquare)i);
13867                     if( i >= gameInfo.holdingsSize ) return FALSE;
13868                     board[i][BOARD_WIDTH-1] = piece;    /* white holdings */
13869                     board[i][BOARD_WIDTH-2]++;          /* black holdings */
13870                 }
13871             }
13872         }
13873         if(*p == ']') *p++;
13874     }
13875
13876     while(*p == ' ') p++;
13877
13878     /* Active color */
13879     switch (*p++) {
13880       case 'w':
13881         *blackPlaysFirst = FALSE;
13882         break;
13883       case 'b':
13884         *blackPlaysFirst = TRUE;
13885         break;
13886       default:
13887         return FALSE;
13888     }
13889
13890     /* [HGM] We NO LONGER ignore the rest of the FEN notation */
13891     /* return the extra info in global variiables             */
13892
13893     /* set defaults in case FEN is incomplete */
13894     FENepStatus = EP_UNKNOWN;
13895     for(i=0; i<nrCastlingRights; i++ ) {
13896         FENcastlingRights[i] =
13897             gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom ? -1 : initialRights[i];
13898     }   /* assume possible unless obviously impossible */
13899     if(initialRights[0]>=0 && board[castlingRank[0]][initialRights[0]] != WhiteRook) FENcastlingRights[0] = -1;
13900     if(initialRights[1]>=0 && board[castlingRank[1]][initialRights[1]] != WhiteRook) FENcastlingRights[1] = -1;
13901     if(initialRights[2]>=0 && board[castlingRank[2]][initialRights[2]] != WhiteKing) FENcastlingRights[2] = -1;
13902     if(initialRights[3]>=0 && board[castlingRank[3]][initialRights[3]] != BlackRook) FENcastlingRights[3] = -1;
13903     if(initialRights[4]>=0 && board[castlingRank[4]][initialRights[4]] != BlackRook) FENcastlingRights[4] = -1;
13904     if(initialRights[5]>=0 && board[castlingRank[5]][initialRights[5]] != BlackKing) FENcastlingRights[5] = -1;
13905     FENrulePlies = 0;
13906
13907     while(*p==' ') p++;
13908     if(nrCastlingRights) {
13909       if(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-') {
13910           /* castling indicator present, so default becomes no castlings */
13911           for(i=0; i<nrCastlingRights; i++ ) {
13912                  FENcastlingRights[i] = -1;
13913           }
13914       }
13915       while(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-' ||
13916              (gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) &&
13917              ( *p >= 'a' && *p < 'a' + gameInfo.boardWidth) ||
13918              ( *p >= 'A' && *p < 'A' + gameInfo.boardWidth)   ) {
13919         char c = *p++; int whiteKingFile=-1, blackKingFile=-1;
13920
13921         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
13922             if(board[BOARD_HEIGHT-1][i] == BlackKing) blackKingFile = i;
13923             if(board[0             ][i] == WhiteKing) whiteKingFile = i;
13924         }
13925         switch(c) {
13926           case'K':
13927               for(i=BOARD_RGHT-1; board[0][i]!=WhiteRook && i>whiteKingFile; i--);
13928               FENcastlingRights[0] = i != whiteKingFile ? i : -1;
13929               FENcastlingRights[2] = whiteKingFile;
13930               break;
13931           case'Q':
13932               for(i=BOARD_LEFT; board[0][i]!=WhiteRook && i<whiteKingFile; i++);
13933               FENcastlingRights[1] = i != whiteKingFile ? i : -1;
13934               FENcastlingRights[2] = whiteKingFile;
13935               break;
13936           case'k':
13937               for(i=BOARD_RGHT-1; board[BOARD_HEIGHT-1][i]!=BlackRook && i>blackKingFile; i--);
13938               FENcastlingRights[3] = i != blackKingFile ? i : -1;
13939               FENcastlingRights[5] = blackKingFile;
13940               break;
13941           case'q':
13942               for(i=BOARD_LEFT; board[BOARD_HEIGHT-1][i]!=BlackRook && i<blackKingFile; i++);
13943               FENcastlingRights[4] = i != blackKingFile ? i : -1;
13944               FENcastlingRights[5] = blackKingFile;
13945           case '-':
13946               break;
13947           default: /* FRC castlings */
13948               if(c >= 'a') { /* black rights */
13949                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
13950                     if(board[BOARD_HEIGHT-1][i] == BlackKing) break;
13951                   if(i == BOARD_RGHT) break;
13952                   FENcastlingRights[5] = i;
13953                   c -= AAA;
13954                   if(board[BOARD_HEIGHT-1][c] <  BlackPawn ||
13955                      board[BOARD_HEIGHT-1][c] >= BlackKing   ) break;
13956                   if(c > i)
13957                       FENcastlingRights[3] = c;
13958                   else
13959                       FENcastlingRights[4] = c;
13960               } else { /* white rights */
13961                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
13962                     if(board[0][i] == WhiteKing) break;
13963                   if(i == BOARD_RGHT) break;
13964                   FENcastlingRights[2] = i;
13965                   c -= AAA - 'a' + 'A';
13966                   if(board[0][c] >= WhiteKing) break;
13967                   if(c > i)
13968                       FENcastlingRights[0] = c;
13969                   else
13970                       FENcastlingRights[1] = c;
13971               }
13972         }
13973       }
13974     if (appData.debugMode) {
13975         fprintf(debugFP, "FEN castling rights:");
13976         for(i=0; i<nrCastlingRights; i++)
13977         fprintf(debugFP, " %d", FENcastlingRights[i]);
13978         fprintf(debugFP, "\n");
13979     }
13980
13981       while(*p==' ') p++;
13982     }
13983
13984     /* read e.p. field in games that know e.p. capture */
13985     if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
13986        gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier ) {
13987       if(*p=='-') {
13988         p++; FENepStatus = EP_NONE;
13989       } else {
13990          char c = *p++ - AAA;
13991
13992          if(c < BOARD_LEFT || c >= BOARD_RGHT) return TRUE;
13993          if(*p >= '0' && *p <='9') *p++;
13994          FENepStatus = c;
13995       }
13996     }
13997
13998
13999     if(sscanf(p, "%d", &i) == 1) {
14000         FENrulePlies = i; /* 50-move ply counter */
14001         /* (The move number is still ignored)    */
14002     }
14003
14004     return TRUE;
14005 }
14006
14007 void
14008 EditPositionPasteFEN(char *fen)
14009 {
14010   if (fen != NULL) {
14011     Board initial_position;
14012
14013     if (!ParseFEN(initial_position, &blackPlaysFirst, fen)) {
14014       DisplayError(_("Bad FEN position in clipboard"), 0);
14015       return ;
14016     } else {
14017       int savedBlackPlaysFirst = blackPlaysFirst;
14018       EditPositionEvent();
14019       blackPlaysFirst = savedBlackPlaysFirst;
14020       CopyBoard(boards[0], initial_position);
14021           /* [HGM] copy FEN attributes as well */
14022           {   int i;
14023               initialRulePlies = FENrulePlies;
14024               epStatus[0] = FENepStatus;
14025               for( i=0; i<nrCastlingRights; i++ )
14026                   castlingRights[0][i] = FENcastlingRights[i];
14027           }
14028       EditPositionDone(FALSE);
14029       DisplayBothClocks();
14030       DrawPosition(FALSE, boards[currentMove]);
14031     }
14032   }
14033 }
14034
14035 static char cseq[12] = "\\   ";
14036
14037 Boolean set_cont_sequence(char *new_seq)
14038 {
14039     int len;
14040     Boolean ret;
14041
14042     // handle bad attempts to set the sequence
14043         if (!new_seq)
14044                 return 0; // acceptable error - no debug
14045
14046     len = strlen(new_seq);
14047     ret = (len > 0) && (len < sizeof(cseq));
14048     if (ret)
14049         strcpy(cseq, new_seq);
14050     else if (appData.debugMode)
14051         fprintf(debugFP, "Invalid continuation sequence \"%s\"  (maximum length is: %u)\n", new_seq, (unsigned) sizeof(cseq)-1);
14052     return ret;
14053 }
14054
14055 /*
14056     reformat a source message so words don't cross the width boundary.  internal
14057     newlines are not removed.  returns the wrapped size (no null character unless
14058     included in source message).  If dest is NULL, only calculate the size required
14059     for the dest buffer.  lp argument indicats line position upon entry, and it's
14060     passed back upon exit.
14061 */
14062 int wrap(char *dest, char *src, int count, int width, int *lp)
14063 {
14064     int len, i, ansi, cseq_len, line, old_line, old_i, old_len, clen;
14065
14066     cseq_len = strlen(cseq);
14067     old_line = line = *lp;
14068     ansi = len = clen = 0;
14069
14070     for (i=0; i < count; i++)
14071     {
14072         if (src[i] == '\033')
14073             ansi = 1;
14074
14075         // if we hit the width, back up
14076         if (!ansi && (line >= width) && src[i] != '\n' && src[i] != ' ')
14077         {
14078             // store i & len in case the word is too long
14079             old_i = i, old_len = len;
14080
14081             // find the end of the last word
14082             while (i && src[i] != ' ' && src[i] != '\n')
14083             {
14084                 i--;
14085                 len--;
14086             }
14087
14088             // word too long?  restore i & len before splitting it
14089             if ((old_i-i+clen) >= width)
14090             {
14091                 i = old_i;
14092                 len = old_len;
14093             }
14094
14095             // extra space?
14096             if (i && src[i-1] == ' ')
14097                 len--;
14098
14099             if (src[i] != ' ' && src[i] != '\n')
14100             {
14101                 i--;
14102                 if (len)
14103                     len--;
14104             }
14105
14106             // now append the newline and continuation sequence
14107             if (dest)
14108                 dest[len] = '\n';
14109             len++;
14110             if (dest)
14111                 strncpy(dest+len, cseq, cseq_len);
14112             len += cseq_len;
14113             line = cseq_len;
14114             clen = cseq_len;
14115             continue;
14116         }
14117
14118         if (dest)
14119             dest[len] = src[i];
14120         len++;
14121         if (!ansi)
14122             line++;
14123         if (src[i] == '\n')
14124             line = 0;
14125         if (src[i] == 'm')
14126             ansi = 0;
14127     }
14128     if (dest && appData.debugMode)
14129     {
14130         fprintf(debugFP, "wrap(count:%d,width:%d,line:%d,len:%d,*lp:%d,src: ",
14131             count, width, line, len, *lp);
14132         show_bytes(debugFP, src, count);
14133         fprintf(debugFP, "\ndest: ");
14134         show_bytes(debugFP, dest, len);
14135         fprintf(debugFP, "\n");
14136     }
14137     *lp = dest ? line : old_line;
14138
14139     return len;
14140 }