backend.c

   1 /*
   2  * backend.c -- Common back end for X and Windows NT versions of
   3  *
   4  * Copyright 1991 by Digital Equipment Corporation, Maynard,
   5  * Massachusetts.
   6  *
   7  * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
   8  * 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   9  *
  10  * Enhancements Copyright 2005 Alessandro Scotti
  11  *
  12  * The following terms apply to Digital Equipment Corporation's copyright
  13  * interest in XBoard:
  14  * ------------------------------------------------------------------------
  15  * All Rights Reserved
  16  *
  17  * Permission to use, copy, modify, and distribute this software and its
  18  * documentation for any purpose and without fee is hereby granted,
  19  * provided that the above copyright notice appear in all copies and that
  20  * both that copyright notice and this permission notice appear in
  21  * supporting documentation, and that the name of Digital not be
  22  * used in advertising or publicity pertaining to distribution of the
  23  * software without specific, written prior permission.
  24  *
  25  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  26  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  27  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  28  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  29  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  30  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  31  * SOFTWARE.
  32  * ------------------------------------------------------------------------
  33  *
  34  * The following terms apply to the enhanced version of XBoard
  35  * distributed by the Free Software Foundation:
  36  * ------------------------------------------------------------------------
  37  *
  38  * GNU XBoard is free software: you can redistribute it and/or modify
  39  * it under the terms of the GNU General Public License as published by
  40  * the Free Software Foundation, either version 3 of the License, or (at
  41  * your option) any later version.
  42  *
  43  * GNU XBoard is distributed in the hope that it will be useful, but
  44  * WITHOUT ANY WARRANTY; without even the implied warranty of
  45  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  46  * General Public License for more details.
  47  *
  48  * You should have received a copy of the GNU General Public License
  49  * along with this program. If not, see http://www.gnu.org/licenses/.  *
  50  *
  51  *------------------------------------------------------------------------
  52  ** See the file ChangeLog for a revision history.  */
  53
  54 /* [AS] Also useful here for debugging */
  55 #ifdef WIN32
  56 #include <windows.h>
  57
  58 #define DoSleep( n ) if( (n) != 0 ) Sleep( (n) );
  59
  60 #else
  61
  62 #define DoSleep( n ) if( (n) >= 0) sleep(n)
  63
  64 #endif
  65
  66 #include "config.h"
  67
  68 #include <assert.h>
  69 #include <stdio.h>
  70 #include <ctype.h>
  71 #include <errno.h>
  72 #include <sys/types.h>
  73 #include <sys/stat.h>
  74 #include <math.h>
  75 #include <ctype.h>
  76
  77 #if STDC_HEADERS
  78 # include <stdlib.h>
  79 # include <string.h>
  80 # include <stdarg.h>
  81 #else /* not STDC_HEADERS */
  82 # if HAVE_STRING_H
  83 #  include <string.h>
  84 # else /* not HAVE_STRING_H */
  85 #  include <strings.h>
  86 # endif /* not HAVE_STRING_H */
  87 #endif /* not STDC_HEADERS */
  88
  89 #if HAVE_SYS_FCNTL_H
  90 # include <sys/fcntl.h>
  91 #else /* not HAVE_SYS_FCNTL_H */
  92 # if HAVE_FCNTL_H
  93 #  include <fcntl.h>
  94 # endif /* HAVE_FCNTL_H */
  95 #endif /* not HAVE_SYS_FCNTL_H */
  96
  97 #if TIME_WITH_SYS_TIME
  98 # include <sys/time.h>
  99 # include <time.h>
 100 #else
 101 # if HAVE_SYS_TIME_H
 102 #  include <sys/time.h>
 103 # else
 104 #  include <time.h>
 105 # endif
 106 #endif
 107
 108 #if defined(_amigados) && !defined(__GNUC__)
 109 struct timezone {
 110     int tz_minuteswest;
 111     int tz_dsttime;
 112 };
 113 extern int gettimeofday(struct timeval *, struct timezone *);
 114 #endif
 115
 116 #if HAVE_UNISTD_H
 117 # include <unistd.h>
 118 #endif
 119
 120 #include "common.h"
 121 #include "frontend.h"
 122 #include "backend.h"
 123 #include "parser.h"
 124 #include "moves.h"
 125 #if ZIPPY
 126 # include "zippy.h"
 127 #endif
 128 #include "backendz.h"
 129 #include "gettext.h"
 130
 131 #ifdef ENABLE_NLS
 132 # define _(s) gettext (s)
 133 # define N_(s) gettext_noop (s)
 134 # define T_(s) gettext(s)
 135 #else
 136 # ifdef WIN32
 137 #   define _(s) T_(s)
 138 #   define N_(s) s
 139 # else
 140 #   define _(s) (s)
 141 #   define N_(s) s
 142 #   define T_(s) s
 143 # endif
 144 #endif
 145
 146
 147 /* A point in time */
 148 typedef struct {
 149     long sec;  /* Assuming this is >= 32 bits */
 150     int ms;    /* Assuming this is >= 16 bits */
 151 } TimeMark;
 152
 153 int establish P((void));
 154 void read_from_player P((InputSourceRef isr, VOIDSTAR closure,
 155                          char *buf, int count, int error));
 156 void read_from_ics P((InputSourceRef isr, VOIDSTAR closure,
 157                       char *buf, int count, int error));
 158 void ics_printf P((char *format, ...));
 159 void SendToICS P((char *s));
 160 void SendToICSDelayed P((char *s, long msdelay));
 161 void SendMoveToICS P((ChessMove moveType, int fromX, int fromY, int toX, int toY, char promoChar));
 162 void HandleMachineMove P((char *message, ChessProgramState *cps));
 163 int AutoPlayOneMove P((void));
 164 int LoadGameOneMove P((ChessMove readAhead));
 165 int LoadGameFromFile P((char *filename, int n, char *title, int useList));
 166 int LoadPositionFromFile P((char *filename, int n, char *title));
 167 int SavePositionToFile P((char *filename));
 168 void ApplyMove P((int fromX, int fromY, int toX, int toY, int promoChar,
 169                                                                                 Board board));
 170 void MakeMove P((int fromX, int fromY, int toX, int toY, int promoChar));
 171 void ShowMove P((int fromX, int fromY, int toX, int toY));
 172 int FinishMove P((ChessMove moveType, int fromX, int fromY, int toX, int toY,
 173                    /*char*/int promoChar));
 174 void BackwardInner P((int target));
 175 void ForwardInner P((int target));
 176 int Adjudicate P((ChessProgramState *cps));
 177 void GameEnds P((ChessMove result, char *resultDetails, int whosays));
 178 void EditPositionDone P((Boolean fakeRights));
 179 void PrintOpponents P((FILE *fp));
 180 void PrintPosition P((FILE *fp, int move));
 181 void StartChessProgram P((ChessProgramState *cps));
 182 void SendToProgram P((char *message, ChessProgramState *cps));
 183 void SendMoveToProgram P((int moveNum, ChessProgramState *cps));
 184 void ReceiveFromProgram P((InputSourceRef isr, VOIDSTAR closure,
 185                            char *buf, int count, int error));
 186 void SendTimeControl P((ChessProgramState *cps,
 187                         int mps, long tc, int inc, int sd, int st));
 188 char *TimeControlTagValue P((void));
 189 void Attention P((ChessProgramState *cps));
 190 void FeedMovesToProgram P((ChessProgramState *cps, int upto));
 191 void ResurrectChessProgram P((void));
 192 void DisplayComment P((int moveNumber, char *text));
 193 void DisplayMove P((int moveNumber));
 194
 195 void ParseGameHistory P((char *game));
 196 void ParseBoard12 P((char *string));
 197 void KeepAlive P((void));
 198 void StartClocks P((void));
 199 void SwitchClocks P((int nr));
 200 void StopClocks P((void));
 201 void ResetClocks P((void));
 202 char *PGNDate P((void));
 203 void SetGameInfo P((void));
 204 Boolean ParseFEN P((Board board, int *blackPlaysFirst, char *fen));
 205 int RegisterMove P((void));
 206 void MakeRegisteredMove P((void));
 207 void TruncateGame P((void));
 208 int looking_at P((char *, int *, char *));
 209 void CopyPlayerNameIntoFileName P((char **, char *));
 210 char *SavePart P((char *));
 211 int SaveGameOldStyle P((FILE *));
 212 int SaveGamePGN P((FILE *));
 213 void GetTimeMark P((TimeMark *));
 214 long SubtractTimeMarks P((TimeMark *, TimeMark *));
 215 int CheckFlags P((void));
 216 long NextTickLength P((long));
 217 void CheckTimeControl P((void));
 218 void show_bytes P((FILE *, char *, int));
 219 int string_to_rating P((char *str));
 220 void ParseFeatures P((char* args, ChessProgramState *cps));
 221 void InitBackEnd3 P((void));
 222 void FeatureDone P((ChessProgramState* cps, int val));
 223 void InitChessProgram P((ChessProgramState *cps, int setup));
 224 void OutputKibitz(int window, char *text);
 225 int PerpetualChase(int first, int last);
 226 int EngineOutputIsUp();
 227 void InitDrawingSizes(int x, int y);
 228
 229 #ifdef WIN32
 230        extern void ConsoleCreate();
 231 #endif
 232
 233 ChessProgramState *WhitePlayer();
 234 void InsertIntoMemo P((int which, char *text)); // [HGM] kibitz: in engineo.c
 235 int VerifyDisplayMode P(());
 236
 237 char *GetInfoFromComment( int, char * ); // [HGM] PV time: returns stripped comment
 238 void InitEngineUCI( const char * iniDir, ChessProgramState * cps ); // [HGM] moved here from winboard.c
 239 char *ProbeBook P((int moveNr, char *book)); // [HGM] book: returns a book move
 240 char *SendMoveToBookUser P((int nr, ChessProgramState *cps, int initial)); // [HGM] book
 241 void ics_update_width P((int new_width));
 242 extern char installDir[MSG_SIZ];
 243 VariantClass startVariant; /* [HGM] nicks: initial variant */
 244
 245 extern int tinyLayout, smallLayout;
 246 ChessProgramStats programStats;
 247 char lastPV[2][2*MSG_SIZ]; /* [HGM] pv: last PV in thinking output of each engine */
 248 int endPV = -1;
 249 static int exiting = 0; /* [HGM] moved to top */
 250 static int setboardSpoiledMachineBlack = 0 /*, errorExitFlag = 0*/;
 251 int startedFromPositionFile = FALSE; Board filePosition;       /* [HGM] loadPos */
 252 Board partnerBoard;     /* [HGM] bughouse: for peeking at partner game          */
 253 int partnerHighlight[2];
 254 Boolean partnerBoardValid = 0;
 255 char partnerStatus[MSG_SIZ];
 256 Boolean partnerUp;
 257 Boolean originalFlip;
 258 Boolean twoBoards = 0;
 259 char endingGame = 0;    /* [HGM] crash: flag to prevent recursion of GameEnds() */
 260 int whiteNPS, blackNPS; /* [HGM] nps: for easily making clocks aware of NPS     */
 261 VariantClass currentlyInitializedVariant; /* [HGM] variantswitch */
 262 int lastIndex = 0;      /* [HGM] autoinc: last game/position used in match mode */
 263 Boolean connectionAlive;/* [HGM] alive: ICS connection status from probing      */
 264 int opponentKibitzes;
 265 int lastSavedGame; /* [HGM] save: ID of game */
 266 char chatPartner[MAX_CHAT][MSG_SIZ]; /* [HGM] chat: list of chatting partners */
 267 extern int chatCount;
 268 int chattingPartner;
 269 char marker[BOARD_RANKS][BOARD_FILES]; /* [HGM] marks for target squares */
 270
 271 /* States for ics_getting_history */
 272 #define H_FALSE 0
 273 #define H_REQUESTED 1
 274 #define H_GOT_REQ_HEADER 2
 275 #define H_GOT_UNREQ_HEADER 3
 276 #define H_GETTING_MOVES 4
 277 #define H_GOT_UNWANTED_HEADER 5
 278
 279 /* whosays values for GameEnds */
 280 #define GE_ICS 0
 281 #define GE_ENGINE 1
 282 #define GE_PLAYER 2
 283 #define GE_FILE 3
 284 #define GE_XBOARD 4
 285 #define GE_ENGINE1 5
 286 #define GE_ENGINE2 6
 287
 288 /* Maximum number of games in a cmail message */
 289 #define CMAIL_MAX_GAMES 20
 290
 291 /* Different types of move when calling RegisterMove */
 292 #define CMAIL_MOVE   0
 293 #define CMAIL_RESIGN 1
 294 #define CMAIL_DRAW   2
 295 #define CMAIL_ACCEPT 3
 296
 297 /* Different types of result to remember for each game */
 298 #define CMAIL_NOT_RESULT 0
 299 #define CMAIL_OLD_RESULT 1
 300 #define CMAIL_NEW_RESULT 2
 301
 302 /* Telnet protocol constants */
 303 #define TN_WILL 0373
 304 #define TN_WONT 0374
 305 #define TN_DO   0375
 306 #define TN_DONT 0376
 307 #define TN_IAC  0377
 308 #define TN_ECHO 0001
 309 #define TN_SGA  0003
 310 #define TN_PORT 23
 311
 312 char*
 313 safeStrCpy( char *dst, const char *src, size_t count )
 314 { // [HGM] made safe
 315   int i;
 316   assert( dst != NULL );
 317   assert( src != NULL );
 318   assert( count > 0 );
 319
 320   for(i=0; i<count; i++) if((dst[i] = src[i]) == NULLCHAR) break;
 321   if(  i == count-1 && dst[i] != NULLCHAR)
 322     {
 323       dst[ count-1 ] = '\0'; // make sure incomplete copy still null-terminated
 324       if(appData.debugMode)
 325       printf("safeStrCpy: copying %s into %s didn't work, not enough space %d\n",src,dst,count);
 326     }
 327
 328   return dst;
 329 }
 330
 331 /* Some compiler can't cast u64 to double
 332  * This function do the job for us:
 333
 334  * We use the highest bit for cast, this only
 335  * works if the highest bit is not
 336  * in use (This should not happen)
 337  *
 338  * We used this for all compiler
 339  */
 340 double
 341 u64ToDouble(u64 value)
 342 {
 343   double r;
 344   u64 tmp = value & u64Const(0x7fffffffffffffff);
 345   r = (double)(s64)tmp;
 346   if (value & u64Const(0x8000000000000000))
 347        r +=  9.2233720368547758080e18; /* 2^63 */
 348  return r;
 349 }
 350
 351 /* Fake up flags for now, as we aren't keeping track of castling
 352    availability yet. [HGM] Change of logic: the flag now only
 353    indicates the type of castlings allowed by the rule of the game.
 354    The actual rights themselves are maintained in the array
 355    castlingRights, as part of the game history, and are not probed
 356    by this function.
 357  */
 358 int
 359 PosFlags(index)
 360 {
 361   int flags = F_ALL_CASTLE_OK;
 362   if ((index % 2) == 0) flags |= F_WHITE_ON_MOVE;
 363   switch (gameInfo.variant) {
 364   case VariantSuicide:
 365     flags &= ~F_ALL_CASTLE_OK;
 366   case VariantGiveaway:         // [HGM] moved this case label one down: seems Giveaway does have castling on ICC!
 367     flags |= F_IGNORE_CHECK;
 368   case VariantLosers:
 369     flags |= F_MANDATORY_CAPTURE; //[HGM] losers: sets flag so TestLegality rejects non-capts if capts exist
 370     break;
 371   case VariantAtomic:
 372     flags |= F_IGNORE_CHECK | F_ATOMIC_CAPTURE;
 373     break;
 374   case VariantKriegspiel:
 375     flags |= F_KRIEGSPIEL_CAPTURE;
 376     break;
 377   case VariantCapaRandom:
 378   case VariantFischeRandom:
 379     flags |= F_FRC_TYPE_CASTLING; /* [HGM] enable this through flag */
 380   case VariantNoCastle:
 381   case VariantShatranj:
 382   case VariantCourier:
 383   case VariantMakruk:
 384     flags &= ~F_ALL_CASTLE_OK;
 385     break;
 386   default:
 387     break;
 388   }
 389   return flags;
 390 }
 391
 392 FILE *gameFileFP, *debugFP;
 393
 394 /*
 395     [AS] Note: sometimes, the sscanf() function is used to parse the input
 396     into a fixed-size buffer. Because of this, we must be prepared to
 397     receive strings as long as the size of the input buffer, which is currently
 398     set to 4K for Windows and 8K for the rest.
 399     So, we must either allocate sufficiently large buffers here, or
 400     reduce the size of the input buffer in the input reading part.
 401 */
 402
 403 char cmailMove[CMAIL_MAX_GAMES][MOVE_LEN], cmailMsg[MSG_SIZ];
 404 char bookOutput[MSG_SIZ*10], thinkOutput[MSG_SIZ*10], lastHint[MSG_SIZ];
 405 char thinkOutput1[MSG_SIZ*10];
 406
 407 ChessProgramState first, second;
 408
 409 /* premove variables */
 410 int premoveToX = 0;
 411 int premoveToY = 0;
 412 int premoveFromX = 0;
 413 int premoveFromY = 0;
 414 int premovePromoChar = 0;
 415 int gotPremove = 0;
 416 Boolean alarmSounded;
 417 /* end premove variables */
 418
 419 char *ics_prefix = "$";
 420 int ics_type = ICS_GENERIC;
 421
 422 int currentMove = 0, forwardMostMove = 0, backwardMostMove = 0;
 423 int pauseExamForwardMostMove = 0;
 424 int nCmailGames = 0, nCmailResults = 0, nCmailMovesRegistered = 0;
 425 int cmailMoveRegistered[CMAIL_MAX_GAMES], cmailResult[CMAIL_MAX_GAMES];
 426 int cmailMsgLoaded = FALSE, cmailMailedMove = FALSE;
 427 int cmailOldMove = -1, firstMove = TRUE, flipView = FALSE;
 428 int blackPlaysFirst = FALSE, startedFromSetupPosition = FALSE;
 429 int searchTime = 0, pausing = FALSE, pauseExamInvalid = FALSE;
 430 int whiteFlag = FALSE, blackFlag = FALSE;
 431 int userOfferedDraw = FALSE;
 432 int ics_user_moved = 0, ics_gamenum = -1, ics_getting_history = H_FALSE;
 433 int matchMode = FALSE, hintRequested = FALSE, bookRequested = FALSE;
 434 int cmailMoveType[CMAIL_MAX_GAMES];
 435 long ics_clock_paused = 0;
 436 ProcRef icsPR = NoProc, cmailPR = NoProc;
 437 InputSourceRef telnetISR = NULL, fromUserISR = NULL, cmailISR = NULL;
 438 GameMode gameMode = BeginningOfGame;
 439 char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2];
 440 char *commentList[MAX_MOVES], *cmailCommentList[CMAIL_MAX_GAMES];
 441 ChessProgramStats_Move pvInfoList[MAX_MOVES]; /* [AS] Info about engine thinking */
 442 int hiddenThinkOutputState = 0; /* [AS] */
 443 int adjudicateLossThreshold = 0; /* [AS] Automatic adjudication */
 444 int adjudicateLossPlies = 6;
 445 char white_holding[64], black_holding[64];
 446 TimeMark lastNodeCountTime;
 447 long lastNodeCount=0;
 448 int shiftKey; // [HGM] set by mouse handler
 449
 450 int have_sent_ICS_logon = 0;
 451 int sending_ICS_login    = 0;
 452 int sending_ICS_password = 0;
 453
 454 int movesPerSession;
 455 int suddenDeath, whiteStartMove, blackStartMove; /* [HGM] for implementation of 'any per time' sessions, as in first part of byoyomi TC */
 456 long whiteTimeRemaining, blackTimeRemaining, timeControl, timeIncrement, lastWhite, lastBlack;
 457 long timeControl_2; /* [AS] Allow separate time controls */
 458 char *fullTimeControlString = NULL, *nextSession, *whiteTC, *blackTC; /* [HGM] secondary TC: merge of MPS, TC and inc */
 459 long timeRemaining[2][MAX_MOVES];
 460 int matchGame = 0;
 461 TimeMark programStartTime;
 462 char ics_handle[MSG_SIZ];
 463 int have_set_title = 0;
 464
 465 /* animateTraining preserves the state of appData.animate
 466  * when Training mode is activated. This allows the
 467  * response to be animated when appData.animate == TRUE and
 468  * appData.animateDragging == TRUE.
 469  */
 470 Boolean animateTraining;
 471
 472 GameInfo gameInfo;
 473
 474 AppData appData;
 475
 476 Board boards[MAX_MOVES];
 477 /* [HGM] Following 7 needed for accurate legality tests: */
 478 signed char  castlingRank[BOARD_FILES]; // and corresponding ranks
 479 signed char  initialRights[BOARD_FILES];
 480 int   nrCastlingRights; // For TwoKings, or to implement castling-unknown status
 481 int   initialRulePlies, FENrulePlies;
 482 FILE  *serverMoves = NULL; // next two for broadcasting (/serverMoves option)
 483 int loadFlag = 0;
 484 int shuffleOpenings;
 485 int mute; // mute all sounds
 486
 487 // [HGM] vari: next 12 to save and restore variations
 488 #define MAX_VARIATIONS 10
 489 int framePtr = MAX_MOVES-1; // points to free stack entry
 490 int storedGames = 0;
 491 int savedFirst[MAX_VARIATIONS];
 492 int savedLast[MAX_VARIATIONS];
 493 int savedFramePtr[MAX_VARIATIONS];
 494 char *savedDetails[MAX_VARIATIONS];
 495 ChessMove savedResult[MAX_VARIATIONS];
 496
 497 void PushTail P((int firstMove, int lastMove));
 498 Boolean PopTail P((Boolean annotate));
 499 void CleanupTail P((void));
 500
 501 ChessSquare  FIDEArray[2][BOARD_FILES] = {
 502     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 503         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 504     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 505         BlackKing, BlackBishop, BlackKnight, BlackRook }
 506 };
 507
 508 ChessSquare twoKingsArray[2][BOARD_FILES] = {
 509     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 510         WhiteKing, WhiteKing, WhiteKnight, WhiteRook },
 511     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 512         BlackKing, BlackKing, BlackKnight, BlackRook }
 513 };
 514
 515 ChessSquare  KnightmateArray[2][BOARD_FILES] = {
 516     { WhiteRook, WhiteMan, WhiteBishop, WhiteQueen,
 517         WhiteUnicorn, WhiteBishop, WhiteMan, WhiteRook },
 518     { BlackRook, BlackMan, BlackBishop, BlackQueen,
 519         BlackUnicorn, BlackBishop, BlackMan, BlackRook }
 520 };
 521
 522 ChessSquare fairyArray[2][BOARD_FILES] = { /* [HGM] Queen side differs from King side */
 523     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 524         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 525     { BlackLance, BlackAlfil, BlackMarshall, BlackAngel,
 526         BlackKing, BlackMarshall, BlackAlfil, BlackLance }
 527 };
 528
 529 ChessSquare ShatranjArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 530     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteKing,
 531         WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 532     { BlackRook, BlackKnight, BlackAlfil, BlackKing,
 533         BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 534 };
 535
 536 ChessSquare makrukArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 537     { WhiteRook, WhiteKnight, WhiteMan, WhiteKing,
 538         WhiteFerz, WhiteMan, WhiteKnight, WhiteRook },
 539     { BlackRook, BlackKnight, BlackMan, BlackFerz,
 540         BlackKing, BlackMan, BlackKnight, BlackRook }
 541 };
 542
 543
 544 #if (BOARD_FILES>=10)
 545 ChessSquare ShogiArray[2][BOARD_FILES] = {
 546     { WhiteQueen, WhiteKnight, WhiteFerz, WhiteWazir,
 547         WhiteKing, WhiteWazir, WhiteFerz, WhiteKnight, WhiteQueen },
 548     { BlackQueen, BlackKnight, BlackFerz, BlackWazir,
 549         BlackKing, BlackWazir, BlackFerz, BlackKnight, BlackQueen }
 550 };
 551
 552 ChessSquare XiangqiArray[2][BOARD_FILES] = {
 553     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteFerz,
 554         WhiteWazir, WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 555     { BlackRook, BlackKnight, BlackAlfil, BlackFerz,
 556         BlackWazir, BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 557 };
 558
 559 ChessSquare CapablancaArray[2][BOARD_FILES] = {
 560     { WhiteRook, WhiteKnight, WhiteAngel, WhiteBishop, WhiteQueen,
 561         WhiteKing, WhiteBishop, WhiteMarshall, WhiteKnight, WhiteRook },
 562     { BlackRook, BlackKnight, BlackAngel, BlackBishop, BlackQueen,
 563         BlackKing, BlackBishop, BlackMarshall, BlackKnight, BlackRook }
 564 };
 565
 566 ChessSquare GreatArray[2][BOARD_FILES] = {
 567     { WhiteDragon, WhiteKnight, WhiteAlfil, WhiteGrasshopper, WhiteKing,
 568         WhiteSilver, WhiteCardinal, WhiteAlfil, WhiteKnight, WhiteDragon },
 569     { BlackDragon, BlackKnight, BlackAlfil, BlackGrasshopper, BlackKing,
 570         BlackSilver, BlackCardinal, BlackAlfil, BlackKnight, BlackDragon },
 571 };
 572
 573 ChessSquare JanusArray[2][BOARD_FILES] = {
 574     { WhiteRook, WhiteAngel, WhiteKnight, WhiteBishop, WhiteKing,
 575         WhiteQueen, WhiteBishop, WhiteKnight, WhiteAngel, WhiteRook },
 576     { BlackRook, BlackAngel, BlackKnight, BlackBishop, BlackKing,
 577         BlackQueen, BlackBishop, BlackKnight, BlackAngel, BlackRook }
 578 };
 579
 580 #ifdef GOTHIC
 581 ChessSquare GothicArray[2][BOARD_FILES] = {
 582     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen, WhiteMarshall,
 583         WhiteKing, WhiteAngel, WhiteBishop, WhiteKnight, WhiteRook },
 584     { BlackRook, BlackKnight, BlackBishop, BlackQueen, BlackMarshall,
 585         BlackKing, BlackAngel, BlackBishop, BlackKnight, BlackRook }
 586 };
 587 #else // !GOTHIC
 588 #define GothicArray CapablancaArray
 589 #endif // !GOTHIC
 590
 591 #ifdef FALCON
 592 ChessSquare FalconArray[2][BOARD_FILES] = {
 593     { WhiteRook, WhiteKnight, WhiteBishop, WhiteLance, WhiteQueen,
 594         WhiteKing, WhiteLance, WhiteBishop, WhiteKnight, WhiteRook },
 595     { BlackRook, BlackKnight, BlackBishop, BlackLance, BlackQueen,
 596         BlackKing, BlackLance, BlackBishop, BlackKnight, BlackRook }
 597 };
 598 #else // !FALCON
 599 #define FalconArray CapablancaArray
 600 #endif // !FALCON
 601
 602 #else // !(BOARD_FILES>=10)
 603 #define XiangqiPosition FIDEArray
 604 #define CapablancaArray FIDEArray
 605 #define GothicArray FIDEArray
 606 #define GreatArray FIDEArray
 607 #endif // !(BOARD_FILES>=10)
 608
 609 #if (BOARD_FILES>=12)
 610 ChessSquare CourierArray[2][BOARD_FILES] = {
 611     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteBishop, WhiteMan, WhiteKing,
 612         WhiteFerz, WhiteWazir, WhiteBishop, WhiteAlfil, WhiteKnight, WhiteRook },
 613     { BlackRook, BlackKnight, BlackAlfil, BlackBishop, BlackMan, BlackKing,
 614         BlackFerz, BlackWazir, BlackBishop, BlackAlfil, BlackKnight, BlackRook }
 615 };
 616 #else // !(BOARD_FILES>=12)
 617 #define CourierArray CapablancaArray
 618 #endif // !(BOARD_FILES>=12)
 619
 620
 621 Board initialPosition;
 622
 623
 624 /* Convert str to a rating. Checks for special cases of "----",
 625
 626    "++++", etc. Also strips ()'s */
 627 int
 628 string_to_rating(str)
 629   char *str;
 630 {
 631   while(*str && !isdigit(*str)) ++str;
 632   if (!*str)
 633     return 0;   /* One of the special "no rating" cases */
 634   else
 635     return atoi(str);
 636 }
 637
 638 void
 639 ClearProgramStats()
 640 {
 641     /* Init programStats */
 642     programStats.movelist[0] = 0;
 643     programStats.depth = 0;
 644     programStats.nr_moves = 0;
 645     programStats.moves_left = 0;
 646     programStats.nodes = 0;
 647     programStats.time = -1;        // [HGM] PGNtime: make invalid to recognize engine output
 648     programStats.score = 0;
 649     programStats.got_only_move = 0;
 650     programStats.got_fail = 0;
 651     programStats.line_is_book = 0;
 652 }
 653
 654 void
 655 InitBackEnd1()
 656 {
 657     int matched, min, sec;
 658
 659     ShowThinkingEvent(); // [HGM] thinking: make sure post/nopost state is set according to options
 660     startVariant = StringToVariant(appData.variant); // [HGM] nicks: remember original variant
 661
 662     GetTimeMark(&programStartTime);
 663     srandom((programStartTime.ms + 1000*programStartTime.sec)*0x1001001); // [HGM] book: makes sure random is unpredictabe to msec level
 664
 665     ClearProgramStats();
 666     programStats.ok_to_send = 1;
 667     programStats.seen_stat = 0;
 668
 669     /*
 670      * Initialize game list
 671      */
 672     ListNew(&gameList);
 673
 674
 675     /*
 676      * Internet chess server status
 677      */
 678     if (appData.icsActive) {
 679         appData.matchMode = FALSE;
 680         appData.matchGames = 0;
 681 #if ZIPPY
 682         appData.noChessProgram = !appData.zippyPlay;
 683 #else
 684         appData.zippyPlay = FALSE;
 685         appData.zippyTalk = FALSE;
 686         appData.noChessProgram = TRUE;
 687 #endif
 688         if (*appData.icsHelper != NULLCHAR) {
 689             appData.useTelnet = TRUE;
 690             appData.telnetProgram = appData.icsHelper;
 691         }
 692     } else {
 693         appData.zippyTalk = appData.zippyPlay = FALSE;
 694     }
 695
 696     /* [AS] Initialize pv info list [HGM] and game state */
 697     {
 698         int i, j;
 699
 700         for( i=0; i<=framePtr; i++ ) {
 701             pvInfoList[i].depth = -1;
 702             boards[i][EP_STATUS] = EP_NONE;
 703             for( j=0; j<BOARD_FILES-2; j++ ) boards[i][CASTLING][j] = NoRights;
 704         }
 705     }
 706
 707     /*
 708      * Parse timeControl resource
 709      */
 710     if (!ParseTimeControl(appData.timeControl, appData.timeIncrement,
 711                           appData.movesPerSession)) {
 712         char buf[MSG_SIZ];
 713         snprintf(buf, sizeof(buf), _("bad timeControl option %s"), appData.timeControl);
 714         DisplayFatalError(buf, 0, 2);
 715     }
 716
 717     /*
 718      * Parse searchTime resource
 719      */
 720     if (*appData.searchTime != NULLCHAR) {
 721         matched = sscanf(appData.searchTime, "%d:%d", &min, &sec);
 722         if (matched == 1) {
 723             searchTime = min * 60;
 724         } else if (matched == 2) {
 725             searchTime = min * 60 + sec;
 726         } else {
 727             char buf[MSG_SIZ];
 728             snprintf(buf, sizeof(buf), _("bad searchTime option %s"), appData.searchTime);
 729             DisplayFatalError(buf, 0, 2);
 730         }
 731     }
 732
 733     /* [AS] Adjudication threshold */
 734     adjudicateLossThreshold = appData.adjudicateLossThreshold;
 735
 736     first.which = _("first");
 737     second.which = _("second");
 738     first.maybeThinking = second.maybeThinking = FALSE;
 739     first.pr = second.pr = NoProc;
 740     first.isr = second.isr = NULL;
 741     first.sendTime = second.sendTime = 2;
 742     first.sendDrawOffers = 1;
 743     if (appData.firstPlaysBlack) {
 744         first.twoMachinesColor = "black\n";
 745         second.twoMachinesColor = "white\n";
 746     } else {
 747         first.twoMachinesColor = "white\n";
 748         second.twoMachinesColor = "black\n";
 749     }
 750     first.program = appData.firstChessProgram;
 751     second.program = appData.secondChessProgram;
 752     first.host = appData.firstHost;
 753     second.host = appData.secondHost;
 754     first.dir = appData.firstDirectory;
 755     second.dir = appData.secondDirectory;
 756     first.other = &second;
 757     second.other = &first;
 758     first.initString = appData.initString;
 759     second.initString = appData.secondInitString;
 760     first.computerString = appData.firstComputerString;
 761     second.computerString = appData.secondComputerString;
 762     first.useSigint = second.useSigint = TRUE;
 763     first.useSigterm = second.useSigterm = TRUE;
 764     first.reuse = appData.reuseFirst;
 765     second.reuse = appData.reuseSecond;
 766     first.nps = appData.firstNPS;   // [HGM] nps: copy nodes per second
 767     second.nps = appData.secondNPS;
 768     first.useSetboard = second.useSetboard = FALSE;
 769     first.useSAN = second.useSAN = FALSE;
 770     first.usePing = second.usePing = FALSE;
 771     first.lastPing = second.lastPing = 0;
 772     first.lastPong = second.lastPong = 0;
 773     first.usePlayother = second.usePlayother = FALSE;
 774     first.useColors = second.useColors = TRUE;
 775     first.useUsermove = second.useUsermove = FALSE;
 776     first.sendICS = second.sendICS = FALSE;
 777     first.sendName = second.sendName = appData.icsActive;
 778     first.sdKludge = second.sdKludge = FALSE;
 779     first.stKludge = second.stKludge = FALSE;
 780     TidyProgramName(first.program, first.host, first.tidy);
 781     TidyProgramName(second.program, second.host, second.tidy);
 782     first.matchWins = second.matchWins = 0;
 783     safeStrCpy(first.variants, appData.variant, sizeof(first.variants)/sizeof(first.variants[0]));
 784     safeStrCpy(second.variants, appData.variant,sizeof(second.variants)/sizeof(second.variants[0]));
 785     first.analysisSupport = second.analysisSupport = 2; /* detect */
 786     first.analyzing = second.analyzing = FALSE;
 787     first.initDone = second.initDone = FALSE;
 788
 789     /* New features added by Tord: */
 790     first.useFEN960 = FALSE; second.useFEN960 = FALSE;
 791     first.useOOCastle = TRUE; second.useOOCastle = TRUE;
 792     /* End of new features added by Tord. */
 793     first.fenOverride  = appData.fenOverride1;
 794     second.fenOverride = appData.fenOverride2;
 795
 796     /* [HGM] time odds: set factor for each machine */
 797     first.timeOdds  = appData.firstTimeOdds;
 798     second.timeOdds = appData.secondTimeOdds;
 799     { float norm = 1;
 800         if(appData.timeOddsMode) {
 801             norm = first.timeOdds;
 802             if(norm > second.timeOdds) norm = second.timeOdds;
 803         }
 804         first.timeOdds /= norm;
 805         second.timeOdds /= norm;
 806     }
 807
 808     /* [HGM] secondary TC: how to handle sessions that do not fit in 'level'*/
 809     first.accumulateTC = appData.firstAccumulateTC;
 810     second.accumulateTC = appData.secondAccumulateTC;
 811     first.maxNrOfSessions = second.maxNrOfSessions = 1;
 812
 813     /* [HGM] debug */
 814     first.debug = second.debug = FALSE;
 815     first.supportsNPS = second.supportsNPS = UNKNOWN;
 816
 817     /* [HGM] options */
 818     first.optionSettings  = appData.firstOptions;
 819     second.optionSettings = appData.secondOptions;
 820
 821     first.scoreIsAbsolute = appData.firstScoreIsAbsolute; /* [AS] */
 822     second.scoreIsAbsolute = appData.secondScoreIsAbsolute; /* [AS] */
 823     first.isUCI = appData.firstIsUCI; /* [AS] */
 824     second.isUCI = appData.secondIsUCI; /* [AS] */
 825     first.hasOwnBookUCI = appData.firstHasOwnBookUCI; /* [AS] */
 826     second.hasOwnBookUCI = appData.secondHasOwnBookUCI; /* [AS] */
 827
 828     if (appData.firstProtocolVersion > PROTOVER
 829         || appData.firstProtocolVersion < 1)
 830       {
 831         char buf[MSG_SIZ];
 832         int len;
 833
 834         len = snprintf(buf, MSG_SIZ, _("protocol version %d not supported"),
 835                        appData.firstProtocolVersion);
 836         if( (len > MSG_SIZ) && appData.debugMode )
 837           fprintf(debugFP, "InitBackEnd1: buffer truncated.\n");
 838
 839         DisplayFatalError(buf, 0, 2);
 840       }
 841     else
 842       {
 843         first.protocolVersion = appData.firstProtocolVersion;
 844       }
 845
 846     if (appData.secondProtocolVersion > PROTOVER
 847         || appData.secondProtocolVersion < 1)
 848       {
 849         char buf[MSG_SIZ];
 850         int len;
 851
 852         len = snprintf(buf, MSG_SIZ, _("protocol version %d not supported"),
 853                        appData.secondProtocolVersion);
 854         if( (len > MSG_SIZ) && appData.debugMode )
 855           fprintf(debugFP, "InitBackEnd1: buffer truncated.\n");
 856
 857         DisplayFatalError(buf, 0, 2);
 858       }
 859     else
 860       {
 861         second.protocolVersion = appData.secondProtocolVersion;
 862       }
 863
 864     if (appData.icsActive) {
 865         appData.clockMode = TRUE;  /* changes dynamically in ICS mode */
 866 //    } else if (*appData.searchTime != NULLCHAR || appData.noChessProgram) {
 867     } else if (appData.noChessProgram) { // [HGM] st: searchTime mode now also is clockMode
 868         appData.clockMode = FALSE;
 869         first.sendTime = second.sendTime = 0;
 870     }
 871
 872 #if ZIPPY
 873     /* Override some settings from environment variables, for backward
 874        compatibility.  Unfortunately it's not feasible to have the env
 875        vars just set defaults, at least in xboard.  Ugh.
 876     */
 877     if (appData.icsActive && (appData.zippyPlay || appData.zippyTalk)) {
 878       ZippyInit();
 879     }
 880 #endif
 881
 882     if (appData.noChessProgram) {
 883         programVersion = (char*) malloc(5 + strlen(PACKAGE_STRING));
 884         sprintf(programVersion, "%s", PACKAGE_STRING);
 885     } else {
 886       /* [HGM] tidy: use tidy name, in stead of full pathname (which was probably a bug due to / vs \ ) */
 887       programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
 888       sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
 889     }
 890
 891     if (!appData.icsActive) {
 892       char buf[MSG_SIZ];
 893       int len;
 894
 895       /* Check for variants that are supported only in ICS mode,
 896          or not at all.  Some that are accepted here nevertheless
 897          have bugs; see comments below.
 898       */
 899       VariantClass variant = StringToVariant(appData.variant);
 900       switch (variant) {
 901       case VariantBughouse:     /* need four players and two boards */
 902       case VariantKriegspiel:   /* need to hide pieces and move details */
 903         /* case VariantFischeRandom: (Fabien: moved below) */
 904         len = snprintf(buf,MSG_SIZ, _("Variant %s supported only in ICS mode"), appData.variant);
 905         if( (len > MSG_SIZ) && appData.debugMode )
 906           fprintf(debugFP, "InitBackEnd1: buffer truncated.\n");
 907
 908         DisplayFatalError(buf, 0, 2);
 909         return;
 910
 911       case VariantUnknown:
 912       case VariantLoadable:
 913       case Variant29:
 914       case Variant30:
 915       case Variant31:
 916       case Variant32:
 917       case Variant33:
 918       case Variant34:
 919       case Variant35:
 920       case Variant36:
 921       default:
 922         len = snprintf(buf, MSG_SIZ, _("Unknown variant name %s"), appData.variant);
 923         if( (len > MSG_SIZ) && appData.debugMode )
 924           fprintf(debugFP, "InitBackEnd1: buffer truncated.\n");
 925
 926         DisplayFatalError(buf, 0, 2);
 927         return;
 928
 929       case VariantXiangqi:    /* [HGM] repetition rules not implemented */
 930       case VariantFairy:      /* [HGM] TestLegality definitely off! */
 931       case VariantGothic:     /* [HGM] should work */
 932       case VariantCapablanca: /* [HGM] should work */
 933       case VariantCourier:    /* [HGM] initial forced moves not implemented */
 934       case VariantShogi:      /* [HGM] could still mate with pawn drop */
 935       case VariantKnightmate: /* [HGM] should work */
 936       case VariantCylinder:   /* [HGM] untested */
 937       case VariantFalcon:     /* [HGM] untested */
 938       case VariantCrazyhouse: /* holdings not shown, ([HGM] fixed that!)
 939                                  offboard interposition not understood */
 940       case VariantNormal:     /* definitely works! */
 941       case VariantWildCastle: /* pieces not automatically shuffled */
 942       case VariantNoCastle:   /* pieces not automatically shuffled */
 943       case VariantFischeRandom: /* [HGM] works and shuffles pieces */
 944       case VariantLosers:     /* should work except for win condition,
 945                                  and doesn't know captures are mandatory */
 946       case VariantSuicide:    /* should work except for win condition,
 947                                  and doesn't know captures are mandatory */
 948       case VariantGiveaway:   /* should work except for win condition,
 949                                  and doesn't know captures are mandatory */
 950       case VariantTwoKings:   /* should work */
 951       case VariantAtomic:     /* should work except for win condition */
 952       case Variant3Check:     /* should work except for win condition */
 953       case VariantShatranj:   /* should work except for all win conditions */
 954       case VariantMakruk:     /* should work except for daw countdown */
 955       case VariantBerolina:   /* might work if TestLegality is off */
 956       case VariantCapaRandom: /* should work */
 957       case VariantJanus:      /* should work */
 958       case VariantSuper:      /* experimental */
 959       case VariantGreat:      /* experimental, requires legality testing to be off */
 960       case VariantSChess:     /* S-Chess, should work */
 961         break;
 962       }
 963     }
 964
 965     InitEngineUCI( installDir, &first );  // [HGM] moved here from winboard.c, to make available in xboard
 966     InitEngineUCI( installDir, &second );
 967 }
 968
 969 int NextIntegerFromString( char ** str, long * value )
 970 {
 971     int result = -1;
 972     char * s = *str;
 973
 974     while( *s == ' ' || *s == '\t' ) {
 975         s++;
 976     }
 977
 978     *value = 0;
 979
 980     if( *s >= '0' && *s <= '9' ) {
 981         while( *s >= '0' && *s <= '9' ) {
 982             *value = *value * 10 + (*s - '0');
 983             s++;
 984         }
 985
 986         result = 0;
 987     }
 988
 989     *str = s;
 990
 991     return result;
 992 }
 993
 994 int NextTimeControlFromString( char ** str, long * value )
 995 {
 996     long temp;
 997     int result = NextIntegerFromString( str, &temp );
 998
 999     if( result == 0 ) {
1000         *value = temp * 60; /* Minutes */
1001         if( **str == ':' ) {
1002             (*str)++;
1003             result = NextIntegerFromString( str, &temp );
1004             *value += temp; /* Seconds */
1005         }
1006     }
1007
1008     return result;
1009 }
1010
1011 int NextSessionFromString( char ** str, int *moves, long * tc, long *inc, int *incType)
1012 {   /* [HGM] routine added to read '+moves/time' for secondary time control. */
1013     int result = -1, type = 0; long temp, temp2;
1014
1015     if(**str != ':') return -1; // old params remain in force!
1016     (*str)++;
1017     if(**str == '*') type = *(*str)++, temp = 0; // sandclock TC
1018     if( NextIntegerFromString( str, &temp ) ) return -1;
1019     if(type) { *moves = 0; *tc = temp * 500; *inc = temp * 1000; *incType = '*'; return 0; }
1020
1021     if(**str != '/') {
1022         /* time only: incremental or sudden-death time control */
1023         if(**str == '+') { /* increment follows; read it */
1024             (*str)++;
1025             if(**str == '!') type = *(*str)++; // Bronstein TC
1026             if(result = NextIntegerFromString( str, &temp2)) return -1;
1027             *inc = temp2 * 1000;
1028             if(**str == '.') { // read fraction of increment
1029                 char *start = ++(*str);
1030                 if(result = NextIntegerFromString( str, &temp2)) return -1;
1031                 temp2 *= 1000;
1032                 while(start++ < *str) temp2 /= 10;
1033                 *inc += temp2;
1034             }
1035         } else *inc = 0;
1036         *moves = 0; *tc = temp * 1000; *incType = type;
1037         return 0;
1038     }
1039
1040     (*str)++; /* classical time control */
1041     result = NextIntegerFromString( str, &temp2); // NOTE: already converted to seconds by ParseTimeControl()
1042
1043     if(result == 0) {
1044         *moves = temp;
1045         *tc    = temp2 * 1000;
1046         *inc   = 0;
1047         *incType = type;
1048     }
1049     return result;
1050 }
1051
1052 int GetTimeQuota(int movenr, int lastUsed, char *tcString)
1053 {   /* [HGM] get time to add from the multi-session time-control string */
1054     int incType, moves=1; /* kludge to force reading of first session */
1055     long time, increment;
1056     char *s = tcString;
1057
1058     if(!*s) return 0; // empty TC string means we ran out of the last sudden-death version
1059     if(appData.debugMode) fprintf(debugFP, "TC string = '%s'\n", tcString);
1060     do {
1061         if(moves) NextSessionFromString(&s, &moves, &time, &increment, &incType);
1062         nextSession = s; suddenDeath = moves == 0 && increment == 0;
1063         if(appData.debugMode) fprintf(debugFP, "mps=%d tc=%d inc=%d\n", moves, (int) time, (int) increment);
1064         if(movenr == -1) return time;    /* last move before new session     */
1065         if(incType == '*') increment = 0; else // for sandclock, time is added while not thinking
1066         if(incType == '!' && lastUsed < increment) increment = lastUsed;
1067         if(!moves) return increment;     /* current session is incremental   */
1068         if(movenr >= 0) movenr -= moves; /* we already finished this session */
1069     } while(movenr >= -1);               /* try again for next session       */
1070
1071     return 0; // no new time quota on this move
1072 }
1073
1074 int
1075 ParseTimeControl(tc, ti, mps)
1076      char *tc;
1077      float ti;
1078      int mps;
1079 {
1080   long tc1;
1081   long tc2;
1082   char buf[MSG_SIZ], buf2[MSG_SIZ], *mytc = tc;
1083   int min, sec=0;
1084
1085   if(ti >= 0 && !strchr(tc, '+') && !strchr(tc, '/') ) mps = 0;
1086   if(!strchr(tc, '+') && !strchr(tc, '/') && sscanf(tc, "%d:%d", &min, &sec) >= 1)
1087       sprintf(mytc=buf2, "%d", 60*min+sec); // convert 'classical' min:sec tc string to seconds
1088   if(ti > 0) {
1089
1090     if(mps)
1091       snprintf(buf, MSG_SIZ, ":%d/%s+%g", mps, mytc, ti);
1092     else
1093       snprintf(buf, MSG_SIZ, ":%s+%g", mytc, ti);
1094   } else {
1095     if(mps)
1096       snprintf(buf, MSG_SIZ, ":%d/%s", mps, mytc);
1097     else
1098       snprintf(buf, MSG_SIZ, ":%s", mytc);
1099   }
1100   fullTimeControlString = StrSave(buf); // this should now be in PGN format
1101
1102   if( NextTimeControlFromString( &tc, &tc1 ) != 0 ) {
1103     return FALSE;
1104   }
1105
1106   if( *tc == '/' ) {
1107     /* Parse second time control */
1108     tc++;
1109
1110     if( NextTimeControlFromString( &tc, &tc2 ) != 0 ) {
1111       return FALSE;
1112     }
1113
1114     if( tc2 == 0 ) {
1115       return FALSE;
1116     }
1117
1118     timeControl_2 = tc2 * 1000;
1119   }
1120   else {
1121     timeControl_2 = 0;
1122   }
1123
1124   if( tc1 == 0 ) {
1125     return FALSE;
1126   }
1127
1128   timeControl = tc1 * 1000;
1129
1130   if (ti >= 0) {
1131     timeIncrement = ti * 1000;  /* convert to ms */
1132     movesPerSession = 0;
1133   } else {
1134     timeIncrement = 0;
1135     movesPerSession = mps;
1136   }
1137   return TRUE;
1138 }
1139
1140 void
1141 InitBackEnd2()
1142 {
1143     if (appData.debugMode) {
1144         fprintf(debugFP, "%s\n", programVersion);
1145     }
1146
1147     set_cont_sequence(appData.wrapContSeq);
1148     if (appData.matchGames > 0) {
1149         appData.matchMode = TRUE;
1150     } else if (appData.matchMode) {
1151         appData.matchGames = 1;
1152     }
1153     if(appData.matchMode && appData.sameColorGames > 0) /* [HGM] alternate: overrule matchGames */
1154         appData.matchGames = appData.sameColorGames;
1155     if(appData.rewindIndex > 1) { /* [HGM] autoinc: rewind implies auto-increment and overrules given index */
1156         if(appData.loadPositionIndex >= 0) appData.loadPositionIndex = -1;
1157         if(appData.loadGameIndex >= 0) appData.loadGameIndex = -1;
1158     }
1159     Reset(TRUE, FALSE);
1160     if (appData.noChessProgram || first.protocolVersion == 1) {
1161       InitBackEnd3();
1162     } else {
1163       /* kludge: allow timeout for initial "feature" commands */
1164       FreezeUI();
1165       DisplayMessage("", _("Starting chess program"));
1166       ScheduleDelayedEvent(InitBackEnd3, FEATURE_TIMEOUT);
1167     }
1168 }
1169
1170 void
1171 InitBackEnd3 P((void))
1172 {
1173     GameMode initialMode;
1174     char buf[MSG_SIZ];
1175     int err, len;
1176
1177     InitChessProgram(&first, startedFromSetupPosition);
1178
1179     if(!appData.noChessProgram) {  /* [HGM] tidy: redo program version to use name from myname feature */
1180         free(programVersion);
1181         programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
1182         sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
1183     }
1184
1185     if (appData.icsActive) {
1186 #ifdef WIN32
1187         /* [DM] Make a console window if needed [HGM] merged ifs */
1188         ConsoleCreate();
1189 #endif
1190         err = establish();
1191         if (err != 0)
1192           {
1193             if (*appData.icsCommPort != NULLCHAR)
1194               len = snprintf(buf, MSG_SIZ, _("Could not open comm port %s"),
1195                              appData.icsCommPort);
1196             else
1197               len = snprintf(buf, MSG_SIZ, _("Could not connect to host %s, port %s"),
1198                         appData.icsHost, appData.icsPort);
1199
1200             if( (len > MSG_SIZ) && appData.debugMode )
1201               fprintf(debugFP, "InitBackEnd3: buffer truncated.\n");
1202
1203             DisplayFatalError(buf, err, 1);
1204             return;
1205         }
1206         SetICSMode();
1207         telnetISR =
1208           AddInputSource(icsPR, FALSE, read_from_ics, &telnetISR);
1209         fromUserISR =
1210           AddInputSource(NoProc, FALSE, read_from_player, &fromUserISR);
1211         if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
1212             ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1213     } else if (appData.noChessProgram) {
1214         SetNCPMode();
1215     } else {
1216         SetGNUMode();
1217     }
1218
1219     if (*appData.cmailGameName != NULLCHAR) {
1220         SetCmailMode();
1221         OpenLoopback(&cmailPR);
1222         cmailISR =
1223           AddInputSource(cmailPR, FALSE, CmailSigHandlerCallBack, &cmailISR);
1224     }
1225
1226     ThawUI();
1227     DisplayMessage("", "");
1228     if (StrCaseCmp(appData.initialMode, "") == 0) {
1229       initialMode = BeginningOfGame;
1230     } else if (StrCaseCmp(appData.initialMode, "TwoMachines") == 0) {
1231       initialMode = TwoMachinesPlay;
1232     } else if (StrCaseCmp(appData.initialMode, "AnalyzeFile") == 0) {
1233       initialMode = AnalyzeFile;
1234     } else if (StrCaseCmp(appData.initialMode, "Analysis") == 0) {
1235       initialMode = AnalyzeMode;
1236     } else if (StrCaseCmp(appData.initialMode, "MachineWhite") == 0) {
1237       initialMode = MachinePlaysWhite;
1238     } else if (StrCaseCmp(appData.initialMode, "MachineBlack") == 0) {
1239       initialMode = MachinePlaysBlack;
1240     } else if (StrCaseCmp(appData.initialMode, "EditGame") == 0) {
1241       initialMode = EditGame;
1242     } else if (StrCaseCmp(appData.initialMode, "EditPosition") == 0) {
1243       initialMode = EditPosition;
1244     } else if (StrCaseCmp(appData.initialMode, "Training") == 0) {
1245       initialMode = Training;
1246     } else {
1247       len = snprintf(buf, MSG_SIZ, _("Unknown initialMode %s"), appData.initialMode);
1248       if( (len > MSG_SIZ) && appData.debugMode )
1249         fprintf(debugFP, "InitBackEnd3: buffer truncated.\n");
1250
1251       DisplayFatalError(buf, 0, 2);
1252       return;
1253     }
1254
1255     if (appData.matchMode) {
1256         /* Set up machine vs. machine match */
1257         if (appData.noChessProgram) {
1258             DisplayFatalError(_("Can't have a match with no chess programs"),
1259                               0, 2);
1260             return;
1261         }
1262         matchMode = TRUE;
1263         matchGame = 1;
1264         if (*appData.loadGameFile != NULLCHAR) {
1265             int index = appData.loadGameIndex; // [HGM] autoinc
1266             if(index<0) lastIndex = index = 1;
1267             if (!LoadGameFromFile(appData.loadGameFile,
1268                                   index,
1269                                   appData.loadGameFile, FALSE)) {
1270                 DisplayFatalError(_("Bad game file"), 0, 1);
1271                 return;
1272             }
1273         } else if (*appData.loadPositionFile != NULLCHAR) {
1274             int index = appData.loadPositionIndex; // [HGM] autoinc
1275             if(index<0) lastIndex = index = 1;
1276             if (!LoadPositionFromFile(appData.loadPositionFile,
1277                                       index,
1278                                       appData.loadPositionFile)) {
1279                 DisplayFatalError(_("Bad position file"), 0, 1);
1280                 return;
1281             }
1282         }
1283         TwoMachinesEvent();
1284     } else if (*appData.cmailGameName != NULLCHAR) {
1285         /* Set up cmail mode */
1286         ReloadCmailMsgEvent(TRUE);
1287     } else {
1288         /* Set up other modes */
1289         if (initialMode == AnalyzeFile) {
1290           if (*appData.loadGameFile == NULLCHAR) {
1291             DisplayFatalError(_("AnalyzeFile mode requires a game file"), 0, 1);
1292             return;
1293           }
1294         }
1295         if (*appData.loadGameFile != NULLCHAR) {
1296             (void) LoadGameFromFile(appData.loadGameFile,
1297                                     appData.loadGameIndex,
1298                                     appData.loadGameFile, TRUE);
1299         } else if (*appData.loadPositionFile != NULLCHAR) {
1300             (void) LoadPositionFromFile(appData.loadPositionFile,
1301                                         appData.loadPositionIndex,
1302                                         appData.loadPositionFile);
1303             /* [HGM] try to make self-starting even after FEN load */
1304             /* to allow automatic setup of fairy variants with wtm */
1305             if(initialMode == BeginningOfGame && !blackPlaysFirst) {
1306                 gameMode = BeginningOfGame;
1307                 setboardSpoiledMachineBlack = 1;
1308             }
1309             /* [HGM] loadPos: make that every new game uses the setup */
1310             /* from file as long as we do not switch variant          */
1311             if(!blackPlaysFirst) {
1312                 startedFromPositionFile = TRUE;
1313                 CopyBoard(filePosition, boards[0]);
1314             }
1315         }
1316         if (initialMode == AnalyzeMode) {
1317           if (appData.noChessProgram) {
1318             DisplayFatalError(_("Analysis mode requires a chess engine"), 0, 2);
1319             return;
1320           }
1321           if (appData.icsActive) {
1322             DisplayFatalError(_("Analysis mode does not work with ICS mode"),0,2);
1323             return;
1324           }
1325           AnalyzeModeEvent();
1326         } else if (initialMode == AnalyzeFile) {
1327           appData.showThinking = TRUE; // [HGM] thinking: moved out of ShowThinkingEvent
1328           ShowThinkingEvent();
1329           AnalyzeFileEvent();
1330           AnalysisPeriodicEvent(1);
1331         } else if (initialMode == MachinePlaysWhite) {
1332           if (appData.noChessProgram) {
1333             DisplayFatalError(_("MachineWhite mode requires a chess engine"),
1334                               0, 2);
1335             return;
1336           }
1337           if (appData.icsActive) {
1338             DisplayFatalError(_("MachineWhite mode does not work with ICS mode"),
1339                               0, 2);
1340             return;
1341           }
1342           MachineWhiteEvent();
1343         } else if (initialMode == MachinePlaysBlack) {
1344           if (appData.noChessProgram) {
1345             DisplayFatalError(_("MachineBlack mode requires a chess engine"),
1346                               0, 2);
1347             return;
1348           }
1349           if (appData.icsActive) {
1350             DisplayFatalError(_("MachineBlack mode does not work with ICS mode"),
1351                               0, 2);
1352             return;
1353           }
1354           MachineBlackEvent();
1355         } else if (initialMode == TwoMachinesPlay) {
1356           if (appData.noChessProgram) {
1357             DisplayFatalError(_("TwoMachines mode requires a chess engine"),
1358                               0, 2);
1359             return;
1360           }
1361           if (appData.icsActive) {
1362             DisplayFatalError(_("TwoMachines mode does not work with ICS mode"),
1363                               0, 2);
1364             return;
1365           }
1366           TwoMachinesEvent();
1367         } else if (initialMode == EditGame) {
1368           EditGameEvent();
1369         } else if (initialMode == EditPosition) {
1370           EditPositionEvent();
1371         } else if (initialMode == Training) {
1372           if (*appData.loadGameFile == NULLCHAR) {
1373             DisplayFatalError(_("Training mode requires a game file"), 0, 2);
1374             return;
1375           }
1376           TrainingEvent();
1377         }
1378     }
1379 }
1380
1381 /*
1382  * Establish will establish a contact to a remote host.port.
1383  * Sets icsPR to a ProcRef for a process (or pseudo-process)
1384  *  used to talk to the host.
1385  * Returns 0 if okay, error code if not.
1386  */
1387 int
1388 establish()
1389 {
1390     char buf[MSG_SIZ];
1391
1392     if (*appData.icsCommPort != NULLCHAR) {
1393         /* Talk to the host through a serial comm port */
1394         return OpenCommPort(appData.icsCommPort, &icsPR);
1395
1396     } else if (*appData.gateway != NULLCHAR) {
1397         if (*appData.remoteShell == NULLCHAR) {
1398             /* Use the rcmd protocol to run telnet program on a gateway host */
1399             snprintf(buf, sizeof(buf), "%s %s %s",
1400                     appData.telnetProgram, appData.icsHost, appData.icsPort);
1401             return OpenRcmd(appData.gateway, appData.remoteUser, buf, &icsPR);
1402
1403         } else {
1404             /* Use the rsh program to run telnet program on a gateway host */
1405             if (*appData.remoteUser == NULLCHAR) {
1406                 snprintf(buf, sizeof(buf), "%s %s %s %s %s", appData.remoteShell,
1407                         appData.gateway, appData.telnetProgram,
1408                         appData.icsHost, appData.icsPort);
1409             } else {
1410                 snprintf(buf, sizeof(buf), "%s %s -l %s %s %s %s",
1411                         appData.remoteShell, appData.gateway,
1412                         appData.remoteUser, appData.telnetProgram,
1413                         appData.icsHost, appData.icsPort);
1414             }
1415             return StartChildProcess(buf, "", &icsPR);
1416
1417         }
1418     } else if (appData.useTelnet) {
1419         return OpenTelnet(appData.icsHost, appData.icsPort, &icsPR);
1420
1421     } else {
1422         /* TCP socket interface differs somewhat between
1423            Unix and NT; handle details in the front end.
1424            */
1425         return OpenTCP(appData.icsHost, appData.icsPort, &icsPR);
1426     }
1427 }
1428
1429 void EscapeExpand(char *p, char *q)
1430 {       // [HGM] initstring: routine to shape up string arguments
1431         while(*p++ = *q++) if(p[-1] == '\\')
1432             switch(*q++) {
1433                 case 'n': p[-1] = '\n'; break;
1434                 case 'r': p[-1] = '\r'; break;
1435                 case 't': p[-1] = '\t'; break;
1436                 case '\\': p[-1] = '\\'; break;
1437                 case 0: *p = 0; return;
1438                 default: p[-1] = q[-1]; break;
1439             }
1440 }
1441
1442 void
1443 show_bytes(fp, buf, count)
1444      FILE *fp;
1445      char *buf;
1446      int count;
1447 {
1448     while (count--) {
1449         if (*buf < 040 || *(unsigned char *) buf > 0177) {
1450             fprintf(fp, "\\%03o", *buf & 0xff);
1451         } else {
1452             putc(*buf, fp);
1453         }
1454         buf++;
1455     }
1456     fflush(fp);
1457 }
1458
1459 /* Returns an errno value */
1460 int
1461 OutputMaybeTelnet(pr, message, count, outError)
1462      ProcRef pr;
1463      char *message;
1464      int count;
1465      int *outError;
1466 {
1467     char buf[8192], *p, *q, *buflim;
1468     int left, newcount, outcount;
1469
1470     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet ||
1471         *appData.gateway != NULLCHAR) {
1472         if (appData.debugMode) {
1473             fprintf(debugFP, ">ICS: ");
1474             show_bytes(debugFP, message, count);
1475             fprintf(debugFP, "\n");
1476         }
1477         return OutputToProcess(pr, message, count, outError);
1478     }
1479
1480     buflim = &buf[sizeof(buf)-1]; /* allow 1 byte for expanding last char */
1481     p = message;
1482     q = buf;
1483     left = count;
1484     newcount = 0;
1485     while (left) {
1486         if (q >= buflim) {
1487             if (appData.debugMode) {
1488                 fprintf(debugFP, ">ICS: ");
1489                 show_bytes(debugFP, buf, newcount);
1490                 fprintf(debugFP, "\n");
1491             }
1492             outcount = OutputToProcess(pr, buf, newcount, outError);
1493             if (outcount < newcount) return -1; /* to be sure */
1494             q = buf;
1495             newcount = 0;
1496         }
1497         if (*p == '\n') {
1498             *q++ = '\r';
1499             newcount++;
1500         } else if (((unsigned char) *p) == TN_IAC) {
1501             *q++ = (char) TN_IAC;
1502             newcount ++;
1503         }
1504         *q++ = *p++;
1505         newcount++;
1506         left--;
1507     }
1508     if (appData.debugMode) {
1509         fprintf(debugFP, ">ICS: ");
1510         show_bytes(debugFP, buf, newcount);
1511         fprintf(debugFP, "\n");
1512     }
1513     outcount = OutputToProcess(pr, buf, newcount, outError);
1514     if (outcount < newcount) return -1; /* to be sure */
1515     return count;
1516 }
1517
1518 void
1519 read_from_player(isr, closure, message, count, error)
1520      InputSourceRef isr;
1521      VOIDSTAR closure;
1522      char *message;
1523      int count;
1524      int error;
1525 {
1526     int outError, outCount;
1527     static int gotEof = 0;
1528
1529     /* Pass data read from player on to ICS */
1530     if (count > 0) {
1531         gotEof = 0;
1532         outCount = OutputMaybeTelnet(icsPR, message, count, &outError);
1533         if (outCount < count) {
1534             DisplayFatalError(_("Error writing to ICS"), outError, 1);
1535         }
1536     } else if (count < 0) {
1537         RemoveInputSource(isr);
1538         DisplayFatalError(_("Error reading from keyboard"), error, 1);
1539     } else if (gotEof++ > 0) {
1540         RemoveInputSource(isr);
1541         DisplayFatalError(_("Got end of file from keyboard"), 0, 0);
1542     }
1543 }
1544
1545 void
1546 KeepAlive()
1547 {   // [HGM] alive: periodically send dummy (date) command to ICS to prevent time-out
1548     if(!connectionAlive) DisplayFatalError("No response from ICS", 0, 1);
1549     connectionAlive = FALSE; // only sticks if no response to 'date' command.
1550     SendToICS("date\n");
1551     if(appData.keepAlive) ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1552 }
1553
1554 /* added routine for printf style output to ics */
1555 void ics_printf(char *format, ...)
1556 {
1557     char buffer[MSG_SIZ];
1558     va_list args;
1559
1560     va_start(args, format);
1561     vsnprintf(buffer, sizeof(buffer), format, args);
1562     buffer[sizeof(buffer)-1] = '\0';
1563     SendToICS(buffer);
1564     va_end(args);
1565 }
1566
1567 void
1568 SendToICS(s)
1569      char *s;
1570 {
1571     int count, outCount, outError;
1572
1573     if (icsPR == NULL) return;
1574
1575     count = strlen(s);
1576     outCount = OutputMaybeTelnet(icsPR, s, count, &outError);
1577     if (outCount < count) {
1578         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1579     }
1580 }
1581
1582 /* This is used for sending logon scripts to the ICS. Sending
1583    without a delay causes problems when using timestamp on ICC
1584    (at least on my machine). */
1585 void
1586 SendToICSDelayed(s,msdelay)
1587      char *s;
1588      long msdelay;
1589 {
1590     int count, outCount, outError;
1591
1592     if (icsPR == NULL) return;
1593
1594     count = strlen(s);
1595     if (appData.debugMode) {
1596         fprintf(debugFP, ">ICS: ");
1597         show_bytes(debugFP, s, count);
1598         fprintf(debugFP, "\n");
1599     }
1600     outCount = OutputToProcessDelayed(icsPR, s, count, &outError,
1601                                       msdelay);
1602     if (outCount < count) {
1603         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1604     }
1605 }
1606
1607
1608 /* Remove all highlighting escape sequences in s
1609    Also deletes any suffix starting with '('
1610    */
1611 char *
1612 StripHighlightAndTitle(s)
1613      char *s;
1614 {
1615     static char retbuf[MSG_SIZ];
1616     char *p = retbuf;
1617
1618     while (*s != NULLCHAR) {
1619         while (*s == '\033') {
1620             while (*s != NULLCHAR && !isalpha(*s)) s++;
1621             if (*s != NULLCHAR) s++;
1622         }
1623         while (*s != NULLCHAR && *s != '\033') {
1624             if (*s == '(' || *s == '[') {
1625                 *p = NULLCHAR;
1626                 return retbuf;
1627             }
1628             *p++ = *s++;
1629         }
1630     }
1631     *p = NULLCHAR;
1632     return retbuf;
1633 }
1634
1635 /* Remove all highlighting escape sequences in s */
1636 char *
1637 StripHighlight(s)
1638      char *s;
1639 {
1640     static char retbuf[MSG_SIZ];
1641     char *p = retbuf;
1642
1643     while (*s != NULLCHAR) {
1644         while (*s == '\033') {
1645             while (*s != NULLCHAR && !isalpha(*s)) s++;
1646             if (*s != NULLCHAR) s++;
1647         }
1648         while (*s != NULLCHAR && *s != '\033') {
1649             *p++ = *s++;
1650         }
1651     }
1652     *p = NULLCHAR;
1653     return retbuf;
1654 }
1655
1656 char *variantNames[] = VARIANT_NAMES;
1657 char *
1658 VariantName(v)
1659      VariantClass v;
1660 {
1661     return variantNames[v];
1662 }
1663
1664
1665 /* Identify a variant from the strings the chess servers use or the
1666    PGN Variant tag names we use. */
1667 VariantClass
1668 StringToVariant(e)
1669      char *e;
1670 {
1671     char *p;
1672     int wnum = -1;
1673     VariantClass v = VariantNormal;
1674     int i, found = FALSE;
1675     char buf[MSG_SIZ];
1676     int len;
1677
1678     if (!e) return v;
1679
1680     /* [HGM] skip over optional board-size prefixes */
1681     if( sscanf(e, "%dx%d_", &i, &i) == 2 ||
1682         sscanf(e, "%dx%d+%d_", &i, &i, &i) == 3 ) {
1683         while( *e++ != '_');
1684     }
1685
1686     if(StrCaseStr(e, "misc/")) { // [HGM] on FICS, misc/shogi is not shogi
1687         v = VariantNormal;
1688         found = TRUE;
1689     } else
1690     for (i=0; i<sizeof(variantNames)/sizeof(char*); i++) {
1691       if (StrCaseStr(e, variantNames[i])) {
1692         v = (VariantClass) i;
1693         found = TRUE;
1694         break;
1695       }
1696     }
1697
1698     if (!found) {
1699       if ((StrCaseStr(e, "fischer") && StrCaseStr(e, "random"))
1700           || StrCaseStr(e, "wild/fr")
1701           || StrCaseStr(e, "frc") || StrCaseStr(e, "960")) {
1702         v = VariantFischeRandom;
1703       } else if ((i = 4, p = StrCaseStr(e, "wild")) ||
1704                  (i = 1, p = StrCaseStr(e, "w"))) {
1705         p += i;
1706         while (*p && (isspace(*p) || *p == '(' || *p == '/')) p++;
1707         if (isdigit(*p)) {
1708           wnum = atoi(p);
1709         } else {
1710           wnum = -1;
1711         }
1712         switch (wnum) {
1713         case 0: /* FICS only, actually */
1714         case 1:
1715           /* Castling legal even if K starts on d-file */
1716           v = VariantWildCastle;
1717           break;
1718         case 2:
1719         case 3:
1720         case 4:
1721           /* Castling illegal even if K & R happen to start in
1722              normal positions. */
1723           v = VariantNoCastle;
1724           break;
1725         case 5:
1726         case 7:
1727         case 8:
1728         case 10:
1729         case 11:
1730         case 12:
1731         case 13:
1732         case 14:
1733         case 15:
1734         case 18:
1735         case 19:
1736           /* Castling legal iff K & R start in normal positions */
1737           v = VariantNormal;
1738           break;
1739         case 6:
1740         case 20:
1741         case 21:
1742           /* Special wilds for position setup; unclear what to do here */
1743           v = VariantLoadable;
1744           break;
1745         case 9:
1746           /* Bizarre ICC game */
1747           v = VariantTwoKings;
1748           break;
1749         case 16:
1750           v = VariantKriegspiel;
1751           break;
1752         case 17:
1753           v = VariantLosers;
1754           break;
1755         case 22:
1756           v = VariantFischeRandom;
1757           break;
1758         case 23:
1759           v = VariantCrazyhouse;
1760           break;
1761         case 24:
1762           v = VariantBughouse;
1763           break;
1764         case 25:
1765           v = Variant3Check;
1766           break;
1767         case 26:
1768           /* Not quite the same as FICS suicide! */
1769           v = VariantGiveaway;
1770           break;
1771         case 27:
1772           v = VariantAtomic;
1773           break;
1774         case 28:
1775           v = VariantShatranj;
1776           break;
1777
1778         /* Temporary names for future ICC types.  The name *will* change in
1779            the next xboard/WinBoard release after ICC defines it. */
1780         case 29:
1781           v = Variant29;
1782           break;
1783         case 30:
1784           v = Variant30;
1785           break;
1786         case 31:
1787           v = Variant31;
1788           break;
1789         case 32:
1790           v = Variant32;
1791           break;
1792         case 33:
1793           v = Variant33;
1794           break;
1795         case 34:
1796           v = Variant34;
1797           break;
1798         case 35:
1799           v = Variant35;
1800           break;
1801         case 36:
1802           v = Variant36;
1803           break;
1804         case 37:
1805           v = VariantShogi;
1806           break;
1807         case 38:
1808           v = VariantXiangqi;
1809           break;
1810         case 39:
1811           v = VariantCourier;
1812           break;
1813         case 40:
1814           v = VariantGothic;
1815           break;
1816         case 41:
1817           v = VariantCapablanca;
1818           break;
1819         case 42:
1820           v = VariantKnightmate;
1821           break;
1822         case 43:
1823           v = VariantFairy;
1824           break;
1825         case 44:
1826           v = VariantCylinder;
1827           break;
1828         case 45:
1829           v = VariantFalcon;
1830           break;
1831         case 46:
1832           v = VariantCapaRandom;
1833           break;
1834         case 47:
1835           v = VariantBerolina;
1836           break;
1837         case 48:
1838           v = VariantJanus;
1839           break;
1840         case 49:
1841           v = VariantSuper;
1842           break;
1843         case 50:
1844           v = VariantGreat;
1845           break;
1846         case -1:
1847           /* Found "wild" or "w" in the string but no number;
1848              must assume it's normal chess. */
1849           v = VariantNormal;
1850           break;
1851         default:
1852           len = snprintf(buf, MSG_SIZ, _("Unknown wild type %d"), wnum);
1853           if( (len > MSG_SIZ) && appData.debugMode )
1854             fprintf(debugFP, "StringToVariant: buffer truncated.\n");
1855
1856           DisplayError(buf, 0);
1857           v = VariantUnknown;
1858           break;
1859         }
1860       }
1861     }
1862     if (appData.debugMode) {
1863       fprintf(debugFP, _("recognized '%s' (%d) as variant %s\n"),
1864               e, wnum, VariantName(v));
1865     }
1866     return v;
1867 }
1868
1869 static int leftover_start = 0, leftover_len = 0;
1870 char star_match[STAR_MATCH_N][MSG_SIZ];
1871
1872 /* Test whether pattern is present at &buf[*index]; if so, return TRUE,
1873    advance *index beyond it, and set leftover_start to the new value of
1874    *index; else return FALSE.  If pattern contains the character '*', it
1875    matches any sequence of characters not containing '\r', '\n', or the
1876    character following the '*' (if any), and the matched sequence(s) are
1877    copied into star_match.
1878    */
1879 int
1880 looking_at(buf, index, pattern)
1881      char *buf;
1882      int *index;
1883      char *pattern;
1884 {
1885     char *bufp = &buf[*index], *patternp = pattern;
1886     int star_count = 0;
1887     char *matchp = star_match[0];
1888
1889     for (;;) {
1890         if (*patternp == NULLCHAR) {
1891             *index = leftover_start = bufp - buf;
1892             *matchp = NULLCHAR;
1893             return TRUE;
1894         }
1895         if (*bufp == NULLCHAR) return FALSE;
1896         if (*patternp == '*') {
1897             if (*bufp == *(patternp + 1)) {
1898                 *matchp = NULLCHAR;
1899                 matchp = star_match[++star_count];
1900                 patternp += 2;
1901                 bufp++;
1902                 continue;
1903             } else if (*bufp == '\n' || *bufp == '\r') {
1904                 patternp++;
1905                 if (*patternp == NULLCHAR)
1906                   continue;
1907                 else
1908                   return FALSE;
1909             } else {
1910                 *matchp++ = *bufp++;
1911                 continue;
1912             }
1913         }
1914         if (*patternp != *bufp) return FALSE;
1915         patternp++;
1916         bufp++;
1917     }
1918 }
1919
1920 void
1921 SendToPlayer(data, length)
1922      char *data;
1923      int length;
1924 {
1925     int error, outCount;
1926     outCount = OutputToProcess(NoProc, data, length, &error);
1927     if (outCount < length) {
1928         DisplayFatalError(_("Error writing to display"), error, 1);
1929     }
1930 }
1931
1932 void
1933 PackHolding(packed, holding)
1934      char packed[];
1935      char *holding;
1936 {
1937     char *p = holding;
1938     char *q = packed;
1939     int runlength = 0;
1940     int curr = 9999;
1941     do {
1942         if (*p == curr) {
1943             runlength++;
1944         } else {
1945             switch (runlength) {
1946               case 0:
1947                 break;
1948               case 1:
1949                 *q++ = curr;
1950                 break;
1951               case 2:
1952                 *q++ = curr;
1953                 *q++ = curr;
1954                 break;
1955               default:
1956                 sprintf(q, "%d", runlength);
1957                 while (*q) q++;
1958                 *q++ = curr;
1959                 break;
1960             }
1961             runlength = 1;
1962             curr = *p;
1963         }
1964     } while (*p++);
1965     *q = NULLCHAR;
1966 }
1967
1968 /* Telnet protocol requests from the front end */
1969 void
1970 TelnetRequest(ddww, option)
1971      unsigned char ddww, option;
1972 {
1973     unsigned char msg[3];
1974     int outCount, outError;
1975
1976     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet) return;
1977
1978     if (appData.debugMode) {
1979         char buf1[8], buf2[8], *ddwwStr, *optionStr;
1980         switch (ddww) {
1981           case TN_DO:
1982             ddwwStr = "DO";
1983             break;
1984           case TN_DONT:
1985             ddwwStr = "DONT";
1986             break;
1987           case TN_WILL:
1988             ddwwStr = "WILL";
1989             break;
1990           case TN_WONT:
1991             ddwwStr = "WONT";
1992             break;
1993           default:
1994             ddwwStr = buf1;
1995             snprintf(buf1,sizeof(buf1)/sizeof(buf1[0]), "%d", ddww);
1996             break;
1997         }
1998         switch (option) {
1999           case TN_ECHO:
2000             optionStr = "ECHO";
2001             break;
2002           default:
2003             optionStr = buf2;
2004             snprintf(buf2,sizeof(buf2)/sizeof(buf2[0]), "%d", option);
2005             break;
2006         }
2007         fprintf(debugFP, ">%s %s ", ddwwStr, optionStr);
2008     }
2009     msg[0] = TN_IAC;
2010     msg[1] = ddww;
2011     msg[2] = option;
2012     outCount = OutputToProcess(icsPR, (char *)msg, 3, &outError);
2013     if (outCount < 3) {
2014         DisplayFatalError(_("Error writing to ICS"), outError, 1);
2015     }
2016 }
2017
2018 void
2019 DoEcho()
2020 {
2021     if (!appData.icsActive) return;
2022     TelnetRequest(TN_DO, TN_ECHO);
2023 }
2024
2025 void
2026 DontEcho()
2027 {
2028     if (!appData.icsActive) return;
2029     TelnetRequest(TN_DONT, TN_ECHO);
2030 }
2031
2032 void
2033 CopyHoldings(Board board, char *holdings, ChessSquare lowestPiece)
2034 {
2035     /* put the holdings sent to us by the server on the board holdings area */
2036     int i, j, holdingsColumn, holdingsStartRow, direction, countsColumn;
2037     char p;
2038     ChessSquare piece;
2039
2040     if(gameInfo.holdingsWidth < 2)  return;
2041     if(gameInfo.variant != VariantBughouse && board[HOLDINGS_SET])
2042         return; // prevent overwriting by pre-board holdings
2043
2044     if( (int)lowestPiece >= BlackPawn ) {
2045         holdingsColumn = 0;
2046         countsColumn = 1;
2047         holdingsStartRow = BOARD_HEIGHT-1;
2048         direction = -1;
2049     } else {
2050         holdingsColumn = BOARD_WIDTH-1;
2051         countsColumn = BOARD_WIDTH-2;
2052         holdingsStartRow = 0;
2053         direction = 1;
2054     }
2055
2056     for(i=0; i<BOARD_HEIGHT; i++) { /* clear holdings */
2057         board[i][holdingsColumn] = EmptySquare;
2058         board[i][countsColumn]   = (ChessSquare) 0;
2059     }
2060     while( (p=*holdings++) != NULLCHAR ) {
2061         piece = CharToPiece( ToUpper(p) );
2062         if(piece == EmptySquare) continue;
2063         /*j = (int) piece - (int) WhitePawn;*/
2064         j = PieceToNumber(piece);
2065         if(j >= gameInfo.holdingsSize) continue; /* ignore pieces that do not fit */
2066         if(j < 0) continue;               /* should not happen */
2067         piece = (ChessSquare) ( (int)piece + (int)lowestPiece );
2068         board[holdingsStartRow+j*direction][holdingsColumn] = piece;
2069         board[holdingsStartRow+j*direction][countsColumn]++;
2070     }
2071 }
2072
2073
2074 void
2075 VariantSwitch(Board board, VariantClass newVariant)
2076 {
2077    int newHoldingsWidth, newWidth = 8, newHeight = 8, i, j;
2078    static Board oldBoard;
2079
2080    startedFromPositionFile = FALSE;
2081    if(gameInfo.variant == newVariant) return;
2082
2083    /* [HGM] This routine is called each time an assignment is made to
2084     * gameInfo.variant during a game, to make sure the board sizes
2085     * are set to match the new variant. If that means adding or deleting
2086     * holdings, we shift the playing board accordingly
2087     * This kludge is needed because in ICS observe mode, we get boards
2088     * of an ongoing game without knowing the variant, and learn about the
2089     * latter only later. This can be because of the move list we requested,
2090     * in which case the game history is refilled from the beginning anyway,
2091     * but also when receiving holdings of a crazyhouse game. In the latter
2092     * case we want to add those holdings to the already received position.
2093     */
2094
2095
2096    if (appData.debugMode) {
2097      fprintf(debugFP, "Switch board from %s to %s\n",
2098              VariantName(gameInfo.variant), VariantName(newVariant));
2099      setbuf(debugFP, NULL);
2100    }
2101    shuffleOpenings = 0;       /* [HGM] shuffle */
2102    gameInfo.holdingsSize = 5; /* [HGM] prepare holdings */
2103    switch(newVariant)
2104      {
2105      case VariantShogi:
2106        newWidth = 9;  newHeight = 9;
2107        gameInfo.holdingsSize = 7;
2108      case VariantBughouse:
2109      case VariantCrazyhouse:
2110        newHoldingsWidth = 2; break;
2111      case VariantGreat:
2112        newWidth = 10;
2113      case VariantSuper:
2114        newHoldingsWidth = 2;
2115        gameInfo.holdingsSize = 8;
2116        break;
2117      case VariantGothic:
2118      case VariantCapablanca:
2119      case VariantCapaRandom:
2120        newWidth = 10;
2121      default:
2122        newHoldingsWidth = gameInfo.holdingsSize = 0;
2123      };
2124
2125    if(newWidth  != gameInfo.boardWidth  ||
2126       newHeight != gameInfo.boardHeight ||
2127       newHoldingsWidth != gameInfo.holdingsWidth ) {
2128
2129      /* shift position to new playing area, if needed */
2130      if(newHoldingsWidth > gameInfo.holdingsWidth) {
2131        for(i=0; i<BOARD_HEIGHT; i++)
2132          for(j=BOARD_RGHT-1; j>=BOARD_LEFT; j--)
2133            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2134              board[i][j];
2135        for(i=0; i<newHeight; i++) {
2136          board[i][0] = board[i][newWidth+2*newHoldingsWidth-1] = EmptySquare;
2137          board[i][1] = board[i][newWidth+2*newHoldingsWidth-2] = (ChessSquare) 0;
2138        }
2139      } else if(newHoldingsWidth < gameInfo.holdingsWidth) {
2140        for(i=0; i<BOARD_HEIGHT; i++)
2141          for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
2142            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2143              board[i][j];
2144      }
2145      gameInfo.boardWidth  = newWidth;
2146      gameInfo.boardHeight = newHeight;
2147      gameInfo.holdingsWidth = newHoldingsWidth;
2148      gameInfo.variant = newVariant;
2149      InitDrawingSizes(-2, 0);
2150    } else gameInfo.variant = newVariant;
2151    CopyBoard(oldBoard, board);   // remember correctly formatted board
2152      InitPosition(FALSE);          /* this sets up board[0], but also other stuff        */
2153    DrawPosition(TRUE, currentMove ? boards[currentMove] : oldBoard);
2154 }
2155
2156 static int loggedOn = FALSE;
2157
2158 /*-- Game start info cache: --*/
2159 int gs_gamenum;
2160 char gs_kind[MSG_SIZ];
2161 static char player1Name[128] = "";
2162 static char player2Name[128] = "";
2163 static char cont_seq[] = "\n\\   ";
2164 static int player1Rating = -1;
2165 static int player2Rating = -1;
2166 /*----------------------------*/
2167
2168 ColorClass curColor = ColorNormal;
2169 int suppressKibitz = 0;
2170
2171 // [HGM] seekgraph
2172 Boolean soughtPending = FALSE;
2173 Boolean seekGraphUp;
2174 #define MAX_SEEK_ADS 200
2175 #define SQUARE 0x80
2176 char *seekAdList[MAX_SEEK_ADS];
2177 int ratingList[MAX_SEEK_ADS], xList[MAX_SEEK_ADS], yList[MAX_SEEK_ADS], seekNrList[MAX_SEEK_ADS], zList[MAX_SEEK_ADS];
2178 float tcList[MAX_SEEK_ADS];
2179 char colorList[MAX_SEEK_ADS];
2180 int nrOfSeekAds = 0;
2181 int minRating = 1010, maxRating = 2800;
2182 int hMargin = 10, vMargin = 20, h, w;
2183 extern int squareSize, lineGap;
2184
2185 void
2186 PlotSeekAd(int i)
2187 {
2188         int x, y, color = 0, r = ratingList[i]; float tc = tcList[i];
2189         xList[i] = yList[i] = -100; // outside graph, so cannot be clicked
2190         if(r < minRating+100 && r >=0 ) r = minRating+100;
2191         if(r > maxRating) r = maxRating;
2192         if(tc < 1.) tc = 1.;
2193         if(tc > 95.) tc = 95.;
2194         x = (w-hMargin-squareSize/8-7)* log(tc)/log(95.) + hMargin;
2195         y = ((double)r - minRating)/(maxRating - minRating)
2196             * (h-vMargin-squareSize/8-1) + vMargin;
2197         if(ratingList[i] < 0) y = vMargin + squareSize/4;
2198         if(strstr(seekAdList[i], " u ")) color = 1;
2199         if(!strstr(seekAdList[i], "lightning") && // for now all wilds same color
2200            !strstr(seekAdList[i], "bullet") &&
2201            !strstr(seekAdList[i], "blitz") &&
2202            !strstr(seekAdList[i], "standard") ) color = 2;
2203         if(strstr(seekAdList[i], "(C) ")) color |= SQUARE; // plot computer seeks as squares
2204         DrawSeekDot(xList[i]=x+3*(color&~SQUARE), yList[i]=h-1-y, colorList[i]=color);
2205 }
2206
2207 void
2208 AddAd(char *handle, char *rating, int base, int inc,  char rated, char *type, int nr, Boolean plot)
2209 {
2210         char buf[MSG_SIZ], *ext = "";
2211         VariantClass v = StringToVariant(type);
2212         if(strstr(type, "wild")) {
2213             ext = type + 4; // append wild number
2214             if(v == VariantFischeRandom) type = "chess960"; else
2215             if(v == VariantLoadable) type = "setup"; else
2216             type = VariantName(v);
2217         }
2218         snprintf(buf, MSG_SIZ, "%s (%s) %d %d %c %s%s", handle, rating, base, inc, rated, type, ext);
2219         if(nrOfSeekAds < MAX_SEEK_ADS-1) {
2220             if(seekAdList[nrOfSeekAds]) free(seekAdList[nrOfSeekAds]);
2221             ratingList[nrOfSeekAds] = -1; // for if seeker has no rating
2222             sscanf(rating, "%d", &ratingList[nrOfSeekAds]);
2223             tcList[nrOfSeekAds] = base + (2./3.)*inc;
2224             seekNrList[nrOfSeekAds] = nr;
2225             zList[nrOfSeekAds] = 0;
2226             seekAdList[nrOfSeekAds++] = StrSave(buf);
2227             if(plot) PlotSeekAd(nrOfSeekAds-1);
2228         }
2229 }
2230
2231 void
2232 EraseSeekDot(int i)
2233 {
2234     int x = xList[i], y = yList[i], d=squareSize/4, k;
2235     DrawSeekBackground(x-squareSize/8, y-squareSize/8, x+squareSize/8+1, y+squareSize/8+1);
2236     if(x < hMargin+d) DrawSeekAxis(hMargin, y-squareSize/8, hMargin, y+squareSize/8+1);
2237     // now replot every dot that overlapped
2238     for(k=0; k<nrOfSeekAds; k++) if(k != i) {
2239         int xx = xList[k], yy = yList[k];
2240         if(xx <= x+d && xx > x-d && yy <= y+d && yy > y-d)
2241             DrawSeekDot(xx, yy, colorList[k]);
2242     }
2243 }
2244
2245 void
2246 RemoveSeekAd(int nr)
2247 {
2248         int i;
2249         for(i=0; i<nrOfSeekAds; i++) if(seekNrList[i] == nr) {
2250             EraseSeekDot(i);
2251             if(seekAdList[i]) free(seekAdList[i]);
2252             seekAdList[i] = seekAdList[--nrOfSeekAds];
2253             seekNrList[i] = seekNrList[nrOfSeekAds];
2254             ratingList[i] = ratingList[nrOfSeekAds];
2255             colorList[i]  = colorList[nrOfSeekAds];
2256             tcList[i] = tcList[nrOfSeekAds];
2257             xList[i]  = xList[nrOfSeekAds];
2258             yList[i]  = yList[nrOfSeekAds];
2259             zList[i]  = zList[nrOfSeekAds];
2260             seekAdList[nrOfSeekAds] = NULL;
2261             break;
2262         }
2263 }
2264
2265 Boolean
2266 MatchSoughtLine(char *line)
2267 {
2268     char handle[MSG_SIZ], rating[MSG_SIZ], type[MSG_SIZ];
2269     int nr, base, inc, u=0; char dummy;
2270
2271     if(sscanf(line, "%d %s %s %d %d rated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
2272        sscanf(line, "%d %s %s %s %d %d rated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7 ||
2273        (u=1) &&
2274        (sscanf(line, "%d %s %s %d %d unrated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
2275         sscanf(line, "%d %s %s %s %d %d unrated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7)  ) {
2276         // match: compact and save the line
2277         AddAd(handle, rating, base, inc, u ? 'u' : 'r', type, nr, FALSE);
2278         return TRUE;
2279     }
2280     return FALSE;
2281 }
2282
2283 int
2284 DrawSeekGraph()
2285 {
2286     int i;
2287     if(!seekGraphUp) return FALSE;
2288     h = BOARD_HEIGHT * (squareSize + lineGap) + lineGap;
2289     w = BOARD_WIDTH  * (squareSize + lineGap) + lineGap;
2290
2291     DrawSeekBackground(0, 0, w, h);
2292     DrawSeekAxis(hMargin, h-1-vMargin, w-5, h-1-vMargin);
2293     DrawSeekAxis(hMargin, h-1-vMargin, hMargin, 5);
2294     for(i=0; i<4000; i+= 100) if(i>=minRating && i<maxRating) {
2295         int yy =((double)i - minRating)/(maxRating - minRating)*(h-vMargin-squareSize/8-1) + vMargin;
2296         yy = h-1-yy;
2297         DrawSeekAxis(hMargin+5*(i%500==0), yy, hMargin-5, yy); // rating ticks
2298         if(i%500 == 0) {
2299             char buf[MSG_SIZ];
2300             snprintf(buf, MSG_SIZ, "%d", i);
2301             DrawSeekText(buf, hMargin+squareSize/8+7, yy);
2302         }
2303     }
2304     DrawSeekText("unrated", hMargin+squareSize/8+7, h-1-vMargin-squareSize/4);
2305     for(i=1; i<100; i+=(i<10?1:5)) {
2306         int xx = (w-hMargin-squareSize/8-7)* log((double)i)/log(95.) + hMargin;
2307         DrawSeekAxis(xx, h-1-vMargin, xx, h-6-vMargin-3*(i%10==0)); // TC ticks
2308         if(i<=5 || (i>40 ? i%20 : i%10) == 0) {
2309             char buf[MSG_SIZ];
2310             snprintf(buf, MSG_SIZ, "%d", i);
2311             DrawSeekText(buf, xx-2-3*(i>9), h-1-vMargin/2);
2312         }
2313     }
2314     for(i=0; i<nrOfSeekAds; i++) PlotSeekAd(i);
2315     return TRUE;
2316 }
2317
2318 int SeekGraphClick(ClickType click, int x, int y, int moving)
2319 {
2320     static int lastDown = 0, displayed = 0, lastSecond;
2321     if(!seekGraphUp) { // initiate cration of seek graph by requesting seek-ad list
2322         if(click == Release || moving) return FALSE;
2323         nrOfSeekAds = 0;
2324         soughtPending = TRUE;
2325         SendToICS(ics_prefix);
2326         SendToICS("sought\n"); // should this be "sought all"?
2327     } else { // issue challenge based on clicked ad
2328         int dist = 10000; int i, closest = 0, second = 0;
2329         for(i=0; i<nrOfSeekAds; i++) {
2330             int d = (x-xList[i])*(x-xList[i]) +  (y-yList[i])*(y-yList[i]) + zList[i];
2331             if(d < dist) { dist = d; closest = i; }
2332             second += (d - zList[i] < 120); // count in-range ads
2333             if(click == Press && moving != 1 && zList[i]>0) zList[i] *= 0.8; // age priority
2334         }
2335         if(dist < 120) {
2336             char buf[MSG_SIZ];
2337             second = (second > 1);
2338             if(displayed != closest || second != lastSecond) {
2339                 DisplayMessage(second ? "!" : "", seekAdList[closest]);
2340                 lastSecond = second; displayed = closest;
2341             }
2342             if(click == Press) {
2343                 if(moving == 2) zList[closest] = 100; // right-click; push to back on press
2344                 lastDown = closest;
2345                 return TRUE;
2346             } // on press 'hit', only show info
2347             if(moving == 2) return TRUE; // ignore right up-clicks on dot
2348             snprintf(buf, MSG_SIZ, "play %d\n", seekNrList[closest]);
2349             SendToICS(ics_prefix);
2350             SendToICS(buf);
2351             return TRUE; // let incoming board of started game pop down the graph
2352         } else if(click == Release) { // release 'miss' is ignored
2353             zList[lastDown] = 100; // make future selection of the rejected ad more difficult
2354             if(moving == 2) { // right up-click
2355                 nrOfSeekAds = 0; // refresh graph
2356                 soughtPending = TRUE;
2357                 SendToICS(ics_prefix);
2358                 SendToICS("sought\n"); // should this be "sought all"?
2359             }
2360             return TRUE;
2361         } else if(moving) { if(displayed >= 0) DisplayMessage("", ""); displayed = -1; return TRUE; }
2362         // press miss or release hit 'pop down' seek graph
2363         seekGraphUp = FALSE;
2364         DrawPosition(TRUE, NULL);
2365     }
2366     return TRUE;
2367 }
2368
2369 void
2370 read_from_ics(isr, closure, data, count, error)
2371      InputSourceRef isr;
2372      VOIDSTAR closure;
2373      char *data;
2374      int count;
2375      int error;
2376 {
2377 #define BUF_SIZE (16*1024) /* overflowed at 8K with "inchannel 1" on FICS? */
2378 #define STARTED_NONE 0
2379 #define STARTED_MOVES 1
2380 #define STARTED_BOARD 2
2381 #define STARTED_OBSERVE 3
2382 #define STARTED_HOLDINGS 4
2383 #define STARTED_CHATTER 5
2384 #define STARTED_COMMENT 6
2385 #define STARTED_MOVES_NOHIDE 7
2386
2387     static int started = STARTED_NONE;
2388     static char parse[20000];
2389     static int parse_pos = 0;
2390     static char buf[BUF_SIZE + 1];
2391     static int firstTime = TRUE, intfSet = FALSE;
2392     static ColorClass prevColor = ColorNormal;
2393     static int savingComment = FALSE;
2394     static int cmatch = 0; // continuation sequence match
2395     char *bp;
2396     char str[MSG_SIZ];
2397     int i, oldi;
2398     int buf_len;
2399     int next_out;
2400     int tkind;
2401     int backup;    /* [DM] For zippy color lines */
2402     char *p;
2403     char talker[MSG_SIZ]; // [HGM] chat
2404     int channel;
2405
2406     connectionAlive = TRUE; // [HGM] alive: I think, therefore I am...
2407
2408     if (appData.debugMode) {
2409       if (!error) {
2410         fprintf(debugFP, "<ICS: ");
2411         show_bytes(debugFP, data, count);
2412         fprintf(debugFP, "\n");
2413       }
2414     }
2415
2416     if (appData.debugMode) { int f = forwardMostMove;
2417         fprintf(debugFP, "ics input %d, castling = %d %d %d %d %d %d\n", f,
2418                 boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
2419                 boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
2420     }
2421     if (count > 0) {
2422         /* If last read ended with a partial line that we couldn't parse,
2423            prepend it to the new read and try again. */
2424         if (leftover_len > 0) {
2425             for (i=0; i<leftover_len; i++)
2426               buf[i] = buf[leftover_start + i];
2427         }
2428
2429     /* copy new characters into the buffer */
2430     bp = buf + leftover_len;
2431     buf_len=leftover_len;
2432     for (i=0; i<count; i++)
2433     {
2434         // ignore these
2435         if (data[i] == '\r')
2436             continue;
2437
2438         // join lines split by ICS?
2439         if (!appData.noJoin)
2440         {
2441             /*
2442                 Joining just consists of finding matches against the
2443                 continuation sequence, and discarding that sequence
2444                 if found instead of copying it.  So, until a match
2445                 fails, there's nothing to do since it might be the
2446                 complete sequence, and thus, something we don't want
2447                 copied.
2448             */
2449             if (data[i] == cont_seq[cmatch])
2450             {
2451                 cmatch++;
2452                 if (cmatch == strlen(cont_seq))
2453                 {
2454                     cmatch = 0; // complete match.  just reset the counter
2455
2456                     /*
2457                         it's possible for the ICS to not include the space
2458                         at the end of the last word, making our [correct]
2459                         join operation fuse two separate words.  the server
2460                         does this when the space occurs at the width setting.
2461                     */
2462                     if (!buf_len || buf[buf_len-1] != ' ')
2463                     {
2464                         *bp++ = ' ';
2465                         buf_len++;
2466                     }
2467                 }
2468                 continue;
2469             }
2470             else if (cmatch)
2471             {
2472                 /*
2473                     match failed, so we have to copy what matched before
2474                     falling through and copying this character.  In reality,
2475                     this will only ever be just the newline character, but
2476                     it doesn't hurt to be precise.
2477                 */
2478                 strncpy(bp, cont_seq, cmatch);
2479                 bp += cmatch;
2480                 buf_len += cmatch;
2481                 cmatch = 0;
2482             }
2483         }
2484
2485         // copy this char
2486         *bp++ = data[i];
2487         buf_len++;
2488     }
2489
2490         buf[buf_len] = NULLCHAR;
2491 //      next_out = leftover_len; // [HGM] should we set this to 0, and not print it in advance?
2492         next_out = 0;
2493         leftover_start = 0;
2494
2495         i = 0;
2496         while (i < buf_len) {
2497             /* Deal with part of the TELNET option negotiation
2498                protocol.  We refuse to do anything beyond the
2499                defaults, except that we allow the WILL ECHO option,
2500                which ICS uses to turn off password echoing when we are
2501                directly connected to it.  We reject this option
2502                if localLineEditing mode is on (always on in xboard)
2503                and we are talking to port 23, which might be a real
2504                telnet server that will try to keep WILL ECHO on permanently.
2505              */
2506             if (buf_len - i >= 3 && (unsigned char) buf[i] == TN_IAC) {
2507                 static int remoteEchoOption = FALSE; /* telnet ECHO option */
2508                 unsigned char option;
2509                 oldi = i;
2510                 switch ((unsigned char) buf[++i]) {
2511                   case TN_WILL:
2512                     if (appData.debugMode)
2513                       fprintf(debugFP, "\n<WILL ");
2514                     switch (option = (unsigned char) buf[++i]) {
2515                       case TN_ECHO:
2516                         if (appData.debugMode)
2517                           fprintf(debugFP, "ECHO ");
2518                         /* Reply only if this is a change, according
2519                            to the protocol rules. */
2520                         if (remoteEchoOption) break;
2521                         if (appData.localLineEditing &&
2522                             atoi(appData.icsPort) == TN_PORT) {
2523                             TelnetRequest(TN_DONT, TN_ECHO);
2524                         } else {
2525                             EchoOff();
2526                             TelnetRequest(TN_DO, TN_ECHO);
2527                             remoteEchoOption = TRUE;
2528                         }
2529                         break;
2530                       default:
2531                         if (appData.debugMode)
2532                           fprintf(debugFP, "%d ", option);
2533                         /* Whatever this is, we don't want it. */
2534                         TelnetRequest(TN_DONT, option);
2535                         break;
2536                     }
2537                     break;
2538                   case TN_WONT:
2539                     if (appData.debugMode)
2540                       fprintf(debugFP, "\n<WONT ");
2541                     switch (option = (unsigned char) buf[++i]) {
2542                       case TN_ECHO:
2543                         if (appData.debugMode)
2544                           fprintf(debugFP, "ECHO ");
2545                         /* Reply only if this is a change, according
2546                            to the protocol rules. */
2547                         if (!remoteEchoOption) break;
2548                         EchoOn();
2549                         TelnetRequest(TN_DONT, TN_ECHO);
2550                         remoteEchoOption = FALSE;
2551                         break;
2552                       default:
2553                         if (appData.debugMode)
2554                           fprintf(debugFP, "%d ", (unsigned char) option);
2555                         /* Whatever this is, it must already be turned
2556                            off, because we never agree to turn on
2557                            anything non-default, so according to the
2558                            protocol rules, we don't reply. */
2559                         break;
2560                     }
2561                     break;
2562                   case TN_DO:
2563                     if (appData.debugMode)
2564                       fprintf(debugFP, "\n<DO ");
2565                     switch (option = (unsigned char) buf[++i]) {
2566                       default:
2567                         /* Whatever this is, we refuse to do it. */
2568                         if (appData.debugMode)
2569                           fprintf(debugFP, "%d ", option);
2570                         TelnetRequest(TN_WONT, option);
2571                         break;
2572                     }
2573                     break;
2574                   case TN_DONT:
2575                     if (appData.debugMode)
2576                       fprintf(debugFP, "\n<DONT ");
2577                     switch (option = (unsigned char) buf[++i]) {
2578                       default:
2579                         if (appData.debugMode)
2580                           fprintf(debugFP, "%d ", option);
2581                         /* Whatever this is, we are already not doing
2582                            it, because we never agree to do anything
2583                            non-default, so according to the protocol
2584                            rules, we don't reply. */
2585                         break;
2586                     }
2587                     break;
2588                   case TN_IAC:
2589                     if (appData.debugMode)
2590                       fprintf(debugFP, "\n<IAC ");
2591                     /* Doubled IAC; pass it through */
2592                     i--;
2593                     break;
2594                   default:
2595                     if (appData.debugMode)
2596                       fprintf(debugFP, "\n<%d ", (unsigned char) buf[i]);
2597                     /* Drop all other telnet commands on the floor */
2598                     break;
2599                 }
2600                 if (oldi > next_out)
2601                   SendToPlayer(&buf[next_out], oldi - next_out);
2602                 if (++i > next_out)
2603                   next_out = i;
2604                 continue;
2605             }
2606
2607             /* OK, this at least will *usually* work */
2608             if (!loggedOn && looking_at(buf, &i, "ics%")) {
2609                 loggedOn = TRUE;
2610             }
2611
2612             if (loggedOn && !intfSet) {
2613                 if (ics_type == ICS_ICC) {
2614                   snprintf(str, MSG_SIZ,
2615                           "/set-quietly interface %s\n/set-quietly style 12\n",
2616                           programVersion);
2617                   if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
2618                       strcat(str, "/set-2 51 1\n/set seek 1\n");
2619                 } else if (ics_type == ICS_CHESSNET) {
2620                   snprintf(str, MSG_SIZ, "/style 12\n");
2621                 } else {
2622                   safeStrCpy(str, "alias $ @\n$set interface ", sizeof(str)/sizeof(str[0]));
2623                   strcat(str, programVersion);
2624                   strcat(str, "\n$iset startpos 1\n$iset ms 1\n");
2625                   if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
2626                       strcat(str, "$iset seekremove 1\n$set seek 1\n");
2627 #ifdef WIN32
2628                   strcat(str, "$iset nohighlight 1\n");
2629 #endif
2630                   strcat(str, "$iset lock 1\n$style 12\n");
2631                 }
2632                 SendToICS(str);
2633                 NotifyFrontendLogin();
2634                 intfSet = TRUE;
2635             }
2636
2637             if (started == STARTED_COMMENT) {
2638                 /* Accumulate characters in comment */
2639                 parse[parse_pos++] = buf[i];
2640                 if (buf[i] == '\n') {
2641                     parse[parse_pos] = NULLCHAR;
2642                     if(chattingPartner>=0) {
2643                         char mess[MSG_SIZ];
2644                         snprintf(mess, MSG_SIZ, "%s%s", talker, parse);
2645                         OutputChatMessage(chattingPartner, mess);
2646                         chattingPartner = -1;
2647                         next_out = i+1; // [HGM] suppress printing in ICS window
2648                     } else
2649                     if(!suppressKibitz) // [HGM] kibitz
2650                         AppendComment(forwardMostMove, StripHighlight(parse), TRUE);
2651                     else { // [HGM kibitz: divert memorized engine kibitz to engine-output window
2652                         int nrDigit = 0, nrAlph = 0, j;
2653                         if(parse_pos > MSG_SIZ - 30) // defuse unreasonably long input
2654                         { parse_pos = MSG_SIZ-30; parse[parse_pos - 1] = '\n'; }
2655                         parse[parse_pos] = NULLCHAR;
2656                         // try to be smart: if it does not look like search info, it should go to
2657                         // ICS interaction window after all, not to engine-output window.
2658                         for(j=0; j<parse_pos; j++) { // count letters and digits
2659                             nrDigit += (parse[j] >= '0' && parse[j] <= '9');
2660                             nrAlph  += (parse[j] >= 'a' && parse[j] <= 'z');
2661                             nrAlph  += (parse[j] >= 'A' && parse[j] <= 'Z');
2662                         }
2663                         if(nrAlph < 9*nrDigit) { // if more than 10% digit we assume search info
2664                             int depth=0; float score;
2665                             if(sscanf(parse, "!!! %f/%d", &score, &depth) == 2 && depth>0) {
2666                                 // [HGM] kibitz: save kibitzed opponent info for PGN and eval graph
2667                                 pvInfoList[forwardMostMove-1].depth = depth;
2668                                 pvInfoList[forwardMostMove-1].score = 100*score;
2669                             }
2670                             OutputKibitz(suppressKibitz, parse);
2671                         } else {
2672                             char tmp[MSG_SIZ];
2673                             snprintf(tmp, MSG_SIZ, _("your opponent kibitzes: %s"), parse);
2674                             SendToPlayer(tmp, strlen(tmp));
2675                         }
2676                         next_out = i+1; // [HGM] suppress printing in ICS window
2677                     }
2678                     started = STARTED_NONE;
2679                 } else {
2680                     /* Don't match patterns against characters in comment */
2681                     i++;
2682                     continue;
2683                 }
2684             }
2685             if (started == STARTED_CHATTER) {
2686                 if (buf[i] != '\n') {
2687                     /* Don't match patterns against characters in chatter */
2688                     i++;
2689                     continue;
2690                 }
2691                 started = STARTED_NONE;
2692                 if(suppressKibitz) next_out = i+1;
2693             }
2694
2695             /* Kludge to deal with rcmd protocol */
2696             if (firstTime && looking_at(buf, &i, "\001*")) {
2697                 DisplayFatalError(&buf[1], 0, 1);
2698                 continue;
2699             } else {
2700                 firstTime = FALSE;
2701             }
2702
2703             if (!loggedOn && looking_at(buf, &i, "chessclub.com")) {
2704                 ics_type = ICS_ICC;
2705                 ics_prefix = "/";
2706                 if (appData.debugMode)
2707                   fprintf(debugFP, "ics_type %d\n", ics_type);
2708                 continue;
2709             }
2710             if (!loggedOn && looking_at(buf, &i, "freechess.org")) {
2711                 ics_type = ICS_FICS;
2712                 ics_prefix = "$";
2713                 if (appData.debugMode)
2714                   fprintf(debugFP, "ics_type %d\n", ics_type);
2715                 continue;
2716             }
2717             if (!loggedOn && looking_at(buf, &i, "chess.net")) {
2718                 ics_type = ICS_CHESSNET;
2719                 ics_prefix = "/";
2720                 if (appData.debugMode)
2721                   fprintf(debugFP, "ics_type %d\n", ics_type);
2722                 continue;
2723             }
2724
2725             if (!loggedOn &&
2726                 (looking_at(buf, &i, "\"*\" is *a registered name") ||
2727                  looking_at(buf, &i, "Logging you in as \"*\"") ||
2728                  looking_at(buf, &i, "will be \"*\""))) {
2729               safeStrCpy(ics_handle, star_match[0], sizeof(ics_handle)/sizeof(ics_handle[0]));
2730               continue;
2731             }
2732
2733             if (loggedOn && !have_set_title && ics_handle[0] != NULLCHAR) {
2734               char buf[MSG_SIZ];
2735               snprintf(buf, sizeof(buf), "%s@%s", ics_handle, appData.icsHost);
2736               DisplayIcsInteractionTitle(buf);
2737               have_set_title = TRUE;
2738             }
2739
2740             /* skip finger notes */
2741             if (started == STARTED_NONE &&
2742                 ((buf[i] == ' ' && isdigit(buf[i+1])) ||
2743                  (buf[i] == '1' && buf[i+1] == '0')) &&
2744                 buf[i+2] == ':' && buf[i+3] == ' ') {
2745               started = STARTED_CHATTER;
2746               i += 3;
2747               continue;
2748             }
2749
2750             oldi = i;
2751             // [HGM] seekgraph: recognize sought lines and end-of-sought message
2752             if(appData.seekGraph) {
2753                 if(soughtPending && MatchSoughtLine(buf+i)) {
2754                     i = strstr(buf+i, "rated") - buf;
2755                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2756                     next_out = leftover_start = i;
2757                     started = STARTED_CHATTER;
2758                     suppressKibitz = TRUE;
2759                     continue;
2760                 }
2761                 if((gameMode == IcsIdle || gameMode == BeginningOfGame)
2762                         && looking_at(buf, &i, "* ads displayed")) {
2763                     soughtPending = FALSE;
2764                     seekGraphUp = TRUE;
2765                     DrawSeekGraph();
2766                     continue;
2767                 }
2768                 if(appData.autoRefresh) {
2769                     if(looking_at(buf, &i, "* (*) seeking * * * * *\"play *\" to respond)\n")) {
2770                         int s = (ics_type == ICS_ICC); // ICC format differs
2771                         if(seekGraphUp)
2772                         AddAd(star_match[0], star_match[1], atoi(star_match[2+s]), atoi(star_match[3+s]),
2773                               star_match[4+s][0], star_match[5-3*s], atoi(star_match[7]), TRUE);
2774                         looking_at(buf, &i, "*% "); // eat prompt
2775                         if(oldi > 0 && buf[oldi-1] == '\n') oldi--; // suppress preceding LF, if any
2776                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2777                         next_out = i; // suppress
2778                         continue;
2779                     }
2780                     if(looking_at(buf, &i, "\nAds removed: *\n") || looking_at(buf, &i, "\031(51 * *\031)")) {
2781                         char *p = star_match[0];
2782                         while(*p) {
2783                             if(seekGraphUp) RemoveSeekAd(atoi(p));
2784                             while(*p && *p++ != ' '); // next
2785                         }
2786                         looking_at(buf, &i, "*% "); // eat prompt
2787                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2788                         next_out = i;
2789                         continue;
2790                     }
2791                 }
2792             }
2793
2794             /* skip formula vars */
2795             if (started == STARTED_NONE &&
2796                 buf[i] == 'f' && isdigit(buf[i+1]) && buf[i+2] == ':') {
2797               started = STARTED_CHATTER;
2798               i += 3;
2799               continue;
2800             }
2801
2802             // [HGM] kibitz: try to recognize opponent engine-score kibitzes, to divert them to engine-output window
2803             if (appData.autoKibitz && started == STARTED_NONE &&
2804                 !appData.icsEngineAnalyze &&                     // [HGM] [DM] ICS analyze
2805                 (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack || gameMode == IcsObserving)) {
2806                 if((looking_at(buf, &i, "* kibitzes: ") || looking_at(buf, &i, "* whispers: ")) &&
2807                    (StrStr(star_match[0], gameInfo.white) == star_match[0] ||
2808                     StrStr(star_match[0], gameInfo.black) == star_match[0]   )) { // kibitz of self or opponent
2809                         suppressKibitz = TRUE;
2810                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2811                         next_out = i;
2812                         if((StrStr(star_match[0], gameInfo.white) == star_match[0]
2813                                 && (gameMode == IcsPlayingWhite)) ||
2814                            (StrStr(star_match[0], gameInfo.black) == star_match[0]
2815                                 && (gameMode == IcsPlayingBlack))   ) // opponent kibitz
2816                             started = STARTED_CHATTER; // own kibitz we simply discard
2817                         else {
2818                             started = STARTED_COMMENT; // make sure it will be collected in parse[]
2819                             parse_pos = 0; parse[0] = NULLCHAR;
2820                             savingComment = TRUE;
2821                             suppressKibitz = gameMode != IcsObserving ? 2 :
2822                                 (StrStr(star_match[0], gameInfo.white) == NULL) + 1;
2823                         }
2824                         continue;
2825                 } else
2826                 if((looking_at(buf, &i, "\nkibitzed to *\n") || looking_at(buf, &i, "kibitzed to *\n") ||
2827                     looking_at(buf, &i, "\n(kibitzed to *\n") || looking_at(buf, &i, "(kibitzed to *\n"))
2828                          && atoi(star_match[0])) {
2829                     // suppress the acknowledgements of our own autoKibitz
2830                     char *p;
2831                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2832                     if(p = strchr(star_match[0], ' ')) p[1] = NULLCHAR; // clip off "players)" on FICS
2833                     SendToPlayer(star_match[0], strlen(star_match[0]));
2834                     if(looking_at(buf, &i, "*% ")) // eat prompt
2835                         suppressKibitz = FALSE;
2836                     next_out = i;
2837                     continue;
2838                 }
2839             } // [HGM] kibitz: end of patch
2840
2841             // [HGM] chat: intercept tells by users for which we have an open chat window
2842             channel = -1;
2843             if(started == STARTED_NONE && (looking_at(buf, &i, "* tells you:") || looking_at(buf, &i, "* says:") ||
2844                                            looking_at(buf, &i, "* whispers:") ||
2845                                            looking_at(buf, &i, "* kibitzes:") ||
2846                                            looking_at(buf, &i, "* shouts:") ||
2847                                            looking_at(buf, &i, "* c-shouts:") ||
2848                                            looking_at(buf, &i, "--> * ") ||
2849                                            looking_at(buf, &i, "*(*):") && (sscanf(star_match[1], "%d", &channel),1) ||
2850                                            looking_at(buf, &i, "*(*)(*):") && (sscanf(star_match[2], "%d", &channel),1) ||
2851                                            looking_at(buf, &i, "*(*)(*)(*):") && (sscanf(star_match[3], "%d", &channel),1) ||
2852                                            looking_at(buf, &i, "*(*)(*)(*)(*):") && sscanf(star_match[4], "%d", &channel) == 1 )) {
2853                 int p;
2854                 sscanf(star_match[0], "%[^(]", talker+1); // strip (C) or (U) off ICS handle
2855                 chattingPartner = -1;
2856
2857                 if(channel >= 0) // channel broadcast; look if there is a chatbox for this channel
2858                 for(p=0; p<MAX_CHAT; p++) {
2859                     if(channel == atoi(chatPartner[p])) {
2860                     talker[0] = '['; strcat(talker, "] ");
2861                     Colorize(channel == 1 ? ColorChannel1 : ColorChannel, FALSE);
2862                     chattingPartner = p; break;
2863                     }
2864                 } else
2865                 if(buf[i-3] == 'e') // kibitz; look if there is a KIBITZ chatbox
2866                 for(p=0; p<MAX_CHAT; p++) {
2867                     if(!strcmp("kibitzes", chatPartner[p])) {
2868                         talker[0] = '['; strcat(talker, "] ");
2869                         chattingPartner = p; break;
2870                     }
2871                 } else
2872                 if(buf[i-3] == 'r') // whisper; look if there is a WHISPER chatbox
2873                 for(p=0; p<MAX_CHAT; p++) {
2874                     if(!strcmp("whispers", chatPartner[p])) {
2875                         talker[0] = '['; strcat(talker, "] ");
2876                         chattingPartner = p; break;
2877                     }
2878                 } else
2879                 if(buf[i-3] == 't' || buf[oldi+2] == '>') {// shout, c-shout or it; look if there is a 'shouts' chatbox
2880                   if(buf[i-8] == '-' && buf[i-3] == 't')
2881                   for(p=0; p<MAX_CHAT; p++) { // c-shout; check if dedicatesd c-shout box exists
2882                     if(!strcmp("c-shouts", chatPartner[p])) {
2883                         talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE);
2884                         chattingPartner = p; break;
2885                     }
2886                   }
2887                   if(chattingPartner < 0)
2888                   for(p=0; p<MAX_CHAT; p++) {
2889                     if(!strcmp("shouts", chatPartner[p])) {
2890                         if(buf[oldi+2] == '>') { talker[0] = '<'; strcat(talker, "> "); Colorize(ColorShout, FALSE); }
2891                         else if(buf[i-8] == '-') { talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE); }
2892                         else { talker[0] = '['; strcat(talker, "] "); Colorize(ColorShout, FALSE); }
2893                         chattingPartner = p; break;
2894                     }
2895                   }
2896                 }
2897                 if(chattingPartner<0) // if not, look if there is a chatbox for this indivdual
2898                 for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
2899                     talker[0] = 0; Colorize(ColorTell, FALSE);
2900                     chattingPartner = p; break;
2901                 }
2902                 if(chattingPartner<0) i = oldi; else {
2903                     Colorize(curColor, TRUE); // undo the bogus colorations we just made to trigger the souds
2904                     if(oldi > 0 && buf[oldi-1] == '\n') oldi--;
2905                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2906                     started = STARTED_COMMENT;
2907                     parse_pos = 0; parse[0] = NULLCHAR;
2908                     savingComment = 3 + chattingPartner; // counts as TRUE
2909                     suppressKibitz = TRUE;
2910                     continue;
2911                 }
2912             } // [HGM] chat: end of patch
2913
2914             if (appData.zippyTalk || appData.zippyPlay) {
2915                 /* [DM] Backup address for color zippy lines */
2916                 backup = i;
2917 #if ZIPPY
2918                if (loggedOn == TRUE)
2919                        if (ZippyControl(buf, &backup) || ZippyConverse(buf, &backup) ||
2920                           (appData.zippyPlay && ZippyMatch(buf, &backup)));
2921 #endif
2922             } // [DM] 'else { ' deleted
2923                 if (
2924                     /* Regular tells and says */
2925                     (tkind = 1, looking_at(buf, &i, "* tells you: ")) ||
2926                     looking_at(buf, &i, "* (your partner) tells you: ") ||
2927                     looking_at(buf, &i, "* says: ") ||
2928                     /* Don't color "message" or "messages" output */
2929                     (tkind = 5, looking_at(buf, &i, "*. * (*:*): ")) ||
2930                     looking_at(buf, &i, "*. * at *:*: ") ||
2931                     looking_at(buf, &i, "--* (*:*): ") ||
2932                     /* Message notifications (same color as tells) */
2933                     looking_at(buf, &i, "* has left a message ") ||
2934                     looking_at(buf, &i, "* just sent you a message:\n") ||
2935                     /* Whispers and kibitzes */
2936                     (tkind = 2, looking_at(buf, &i, "* whispers: ")) ||
2937                     looking_at(buf, &i, "* kibitzes: ") ||
2938                     /* Channel tells */
2939                     (tkind = 3, looking_at(buf, &i, "*(*: "))) {
2940
2941                   if (tkind == 1 && strchr(star_match[0], ':')) {
2942                       /* Avoid "tells you:" spoofs in channels */
2943                      tkind = 3;
2944                   }
2945                   if (star_match[0][0] == NULLCHAR ||
2946                       strchr(star_match[0], ' ') ||
2947                       (tkind == 3 && strchr(star_match[1], ' '))) {
2948                     /* Reject bogus matches */
2949                     i = oldi;
2950                   } else {
2951                     if (appData.colorize) {
2952                       if (oldi > next_out) {
2953                         SendToPlayer(&buf[next_out], oldi - next_out);
2954                         next_out = oldi;
2955                       }
2956                       switch (tkind) {
2957                       case 1:
2958                         Colorize(ColorTell, FALSE);
2959                         curColor = ColorTell;
2960                         break;
2961                       case 2:
2962                         Colorize(ColorKibitz, FALSE);
2963                         curColor = ColorKibitz;
2964                         break;
2965                       case 3:
2966                         p = strrchr(star_match[1], '(');
2967                         if (p == NULL) {
2968                           p = star_match[1];
2969                         } else {
2970                           p++;
2971                         }
2972                         if (atoi(p) == 1) {
2973                           Colorize(ColorChannel1, FALSE);
2974                           curColor = ColorChannel1;
2975                         } else {
2976                           Colorize(ColorChannel, FALSE);
2977                           curColor = ColorChannel;
2978                         }
2979                         break;
2980                       case 5:
2981                         curColor = ColorNormal;
2982                         break;
2983                       }
2984                     }
2985                     if (started == STARTED_NONE && appData.autoComment &&
2986                         (gameMode == IcsObserving ||
2987                          gameMode == IcsPlayingWhite ||
2988                          gameMode == IcsPlayingBlack)) {
2989                       parse_pos = i - oldi;
2990                       memcpy(parse, &buf[oldi], parse_pos);
2991                       parse[parse_pos] = NULLCHAR;
2992                       started = STARTED_COMMENT;
2993                       savingComment = TRUE;
2994                     } else {
2995                       started = STARTED_CHATTER;
2996                       savingComment = FALSE;
2997                     }
2998                     loggedOn = TRUE;
2999                     continue;
3000                   }
3001                 }
3002
3003                 if (looking_at(buf, &i, "* s-shouts: ") ||
3004                     looking_at(buf, &i, "* c-shouts: ")) {
3005                     if (appData.colorize) {
3006                         if (oldi > next_out) {
3007                             SendToPlayer(&buf[next_out], oldi - next_out);
3008                             next_out = oldi;
3009                         }
3010                         Colorize(ColorSShout, FALSE);
3011                         curColor = ColorSShout;
3012                     }
3013                     loggedOn = TRUE;
3014                     started = STARTED_CHATTER;
3015                     continue;
3016                 }
3017
3018                 if (looking_at(buf, &i, "--->")) {
3019                     loggedOn = TRUE;
3020                     continue;
3021                 }
3022
3023                 if (looking_at(buf, &i, "* shouts: ") ||
3024                     looking_at(buf, &i, "--> ")) {
3025                     if (appData.colorize) {
3026                         if (oldi > next_out) {
3027                             SendToPlayer(&buf[next_out], oldi - next_out);
3028                             next_out = oldi;
3029                         }
3030                         Colorize(ColorShout, FALSE);
3031                         curColor = ColorShout;
3032                     }
3033                     loggedOn = TRUE;
3034                     started = STARTED_CHATTER;
3035                     continue;
3036                 }
3037
3038                 if (looking_at( buf, &i, "Challenge:")) {
3039                     if (appData.colorize) {
3040                         if (oldi > next_out) {
3041                             SendToPlayer(&buf[next_out], oldi - next_out);
3042                             next_out = oldi;
3043                         }
3044                         Colorize(ColorChallenge, FALSE);
3045                         curColor = ColorChallenge;
3046                     }
3047                     loggedOn = TRUE;
3048                     continue;
3049                 }
3050
3051                 if (looking_at(buf, &i, "* offers you") ||
3052                     looking_at(buf, &i, "* offers to be") ||
3053                     looking_at(buf, &i, "* would like to") ||
3054                     looking_at(buf, &i, "* requests to") ||
3055                     looking_at(buf, &i, "Your opponent offers") ||
3056                     looking_at(buf, &i, "Your opponent requests")) {
3057
3058                     if (appData.colorize) {
3059                         if (oldi > next_out) {
3060                             SendToPlayer(&buf[next_out], oldi - next_out);
3061                             next_out = oldi;
3062                         }
3063                         Colorize(ColorRequest, FALSE);
3064                         curColor = ColorRequest;
3065                     }
3066                     continue;
3067                 }
3068
3069                 if (looking_at(buf, &i, "* (*) seeking")) {
3070                     if (appData.colorize) {
3071                         if (oldi > next_out) {
3072                             SendToPlayer(&buf[next_out], oldi - next_out);
3073                             next_out = oldi;
3074                         }
3075                         Colorize(ColorSeek, FALSE);
3076                         curColor = ColorSeek;
3077                     }
3078                     continue;
3079             }
3080
3081             if (looking_at(buf, &i, "\\   ")) {
3082                 if (prevColor != ColorNormal) {
3083                     if (oldi > next_out) {
3084                         SendToPlayer(&buf[next_out], oldi - next_out);
3085                         next_out = oldi;
3086                     }
3087                     Colorize(prevColor, TRUE);
3088                     curColor = prevColor;
3089                 }
3090                 if (savingComment) {
3091                     parse_pos = i - oldi;
3092                     memcpy(parse, &buf[oldi], parse_pos);
3093                     parse[parse_pos] = NULLCHAR;
3094                     started = STARTED_COMMENT;
3095                     if(savingComment >= 3) // [HGM] chat: continuation of line for chat box
3096                         chattingPartner = savingComment - 3; // kludge to remember the box
3097                 } else {
3098                     started = STARTED_CHATTER;
3099                 }
3100                 continue;
3101             }
3102
3103             if (looking_at(buf, &i, "Black Strength :") ||
3104                 looking_at(buf, &i, "<<< style 10 board >>>") ||
3105                 looking_at(buf, &i, "<10>") ||
3106                 looking_at(buf, &i, "#@#")) {
3107                 /* Wrong board style */
3108                 loggedOn = TRUE;
3109                 SendToICS(ics_prefix);
3110                 SendToICS("set style 12\n");
3111                 SendToICS(ics_prefix);
3112                 SendToICS("refresh\n");
3113                 continue;
3114             }
3115
3116             if (!have_sent_ICS_logon && looking_at(buf, &i, "login:")) {
3117                 ICSInitScript();
3118                 have_sent_ICS_logon = 1;
3119                 /* if we don't send the login/password via icsLogon, use special readline
3120                    code for it */
3121                 if (strlen(appData.icsLogon)==0)
3122                   {
3123                     sending_ICS_password = 0; // in case we come back to login
3124                     sending_ICS_login = 1;
3125                   };
3126                 continue;
3127             }
3128             /* need to shadow the password */
3129             if (!sending_ICS_password && looking_at(buf, &i, "password:")) {
3130               /* if we don't send the login/password via icsLogon, use special readline
3131                  code for it */
3132               if (strlen(appData.icsLogon)==0)
3133                 sending_ICS_password = 1;
3134               continue;
3135             }
3136
3137             if (ics_getting_history != H_GETTING_MOVES /*smpos kludge*/ &&
3138                 (looking_at(buf, &i, "\n<12> ") ||
3139                  looking_at(buf, &i, "<12> "))) {
3140                 loggedOn = TRUE;
3141                 if (oldi > next_out) {
3142                     SendToPlayer(&buf[next_out], oldi - next_out);
3143                 }
3144                 next_out = i;
3145                 started = STARTED_BOARD;
3146                 parse_pos = 0;
3147                 continue;
3148             }
3149
3150             if ((started == STARTED_NONE && looking_at(buf, &i, "\n<b1> ")) ||
3151                 looking_at(buf, &i, "<b1> ")) {
3152                 if (oldi > next_out) {
3153                     SendToPlayer(&buf[next_out], oldi - next_out);
3154                 }
3155                 next_out = i;
3156                 started = STARTED_HOLDINGS;
3157                 parse_pos = 0;
3158                 continue;
3159             }
3160
3161             if (looking_at(buf, &i, "* *vs. * *--- *")) {
3162                 loggedOn = TRUE;
3163                 /* Header for a move list -- first line */
3164
3165                 switch (ics_getting_history) {
3166                   case H_FALSE:
3167                     switch (gameMode) {
3168                       case IcsIdle:
3169                       case BeginningOfGame:
3170                         /* User typed "moves" or "oldmoves" while we
3171                            were idle.  Pretend we asked for these
3172                            moves and soak them up so user can step
3173                            through them and/or save them.
3174                            */
3175                         Reset(FALSE, TRUE);
3176                         gameMode = IcsObserving;
3177                         ModeHighlight();
3178                         ics_gamenum = -1;
3179                         ics_getting_history = H_GOT_UNREQ_HEADER;
3180                         break;
3181                       case EditGame: /*?*/
3182                       case EditPosition: /*?*/
3183                         /* Should above feature work in these modes too? */
3184                         /* For now it doesn't */
3185                         ics_getting_history = H_GOT_UNWANTED_HEADER;
3186                         break;
3187                       default:
3188                         ics_getting_history = H_GOT_UNWANTED_HEADER;
3189                         break;
3190                     }
3191                     break;
3192                   case H_REQUESTED:
3193                     /* Is this the right one? */
3194                     if (gameInfo.white && gameInfo.black &&
3195                         strcmp(gameInfo.white, star_match[0]) == 0 &&
3196                         strcmp(gameInfo.black, star_match[2]) == 0) {
3197                         /* All is well */
3198                         ics_getting_history = H_GOT_REQ_HEADER;
3199                     }
3200                     break;
3201                   case H_GOT_REQ_HEADER:
3202                   case H_GOT_UNREQ_HEADER:
3203                   case H_GOT_UNWANTED_HEADER:
3204                   case H_GETTING_MOVES:
3205                     /* Should not happen */
3206                     DisplayError(_("Error gathering move list: two headers"), 0);
3207                     ics_getting_history = H_FALSE;
3208                     break;
3209                 }
3210
3211                 /* Save player ratings into gameInfo if needed */
3212                 if ((ics_getting_history == H_GOT_REQ_HEADER ||
3213                      ics_getting_history == H_GOT_UNREQ_HEADER) &&
3214                     (gameInfo.whiteRating == -1 ||
3215                      gameInfo.blackRating == -1)) {
3216
3217                     gameInfo.whiteRating = string_to_rating(star_match[1]);
3218                     gameInfo.blackRating = string_to_rating(star_match[3]);
3219                     if (appData.debugMode)
3220                       fprintf(debugFP, _("Ratings from header: W %d, B %d\n"),
3221                               gameInfo.whiteRating, gameInfo.blackRating);
3222                 }
3223                 continue;
3224             }
3225
3226             if (looking_at(buf, &i,
3227               "* * match, initial time: * minute*, increment: * second")) {
3228                 /* Header for a move list -- second line */
3229                 /* Initial board will follow if this is a wild game */
3230                 if (gameInfo.event != NULL) free(gameInfo.event);
3231                 snprintf(str, MSG_SIZ, "ICS %s %s match", star_match[0], star_match[1]);
3232                 gameInfo.event = StrSave(str);
3233                 /* [HGM] we switched variant. Translate boards if needed. */
3234                 VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event));
3235                 continue;
3236             }
3237
3238             if (looking_at(buf, &i, "Move  ")) {
3239                 /* Beginning of a move list */
3240                 switch (ics_getting_history) {
3241                   case H_FALSE:
3242                     /* Normally should not happen */
3243                     /* Maybe user hit reset while we were parsing */
3244                     break;
3245                   case H_REQUESTED:
3246                     /* Happens if we are ignoring a move list that is not
3247                      * the one we just requested.  Common if the user
3248                      * tries to observe two games without turning off
3249                      * getMoveList */
3250                     break;
3251                   case H_GETTING_MOVES:
3252                     /* Should not happen */
3253                     DisplayError(_("Error gathering move list: nested"), 0);
3254                     ics_getting_history = H_FALSE;
3255                     break;
3256                   case H_GOT_REQ_HEADER:
3257                     ics_getting_history = H_GETTING_MOVES;
3258                     started = STARTED_MOVES;
3259                     parse_pos = 0;
3260                     if (oldi > next_out) {
3261                         SendToPlayer(&buf[next_out], oldi - next_out);
3262                     }
3263                     break;
3264                   case H_GOT_UNREQ_HEADER:
3265                     ics_getting_history = H_GETTING_MOVES;
3266                     started = STARTED_MOVES_NOHIDE;
3267                     parse_pos = 0;
3268                     break;
3269                   case H_GOT_UNWANTED_HEADER:
3270                     ics_getting_history = H_FALSE;
3271                     break;
3272                 }
3273                 continue;
3274             }
3275
3276             if (looking_at(buf, &i, "% ") ||
3277                 ((started == STARTED_MOVES || started == STARTED_MOVES_NOHIDE)
3278                  && looking_at(buf, &i, "}*"))) { char *bookHit = NULL; // [HGM] book
3279                 if(ics_type == ICS_ICC && soughtPending) { // [HGM] seekgraph: on ICC sought-list has no termination line
3280                     soughtPending = FALSE;
3281                     seekGraphUp = TRUE;
3282                     DrawSeekGraph();
3283                 }
3284                 if(suppressKibitz) next_out = i;
3285                 savingComment = FALSE;
3286                 suppressKibitz = 0;
3287                 switch (started) {
3288                   case STARTED_MOVES:
3289                   case STARTED_MOVES_NOHIDE:
3290                     memcpy(&parse[parse_pos], &buf[oldi], i - oldi);
3291                     parse[parse_pos + i - oldi] = NULLCHAR;
3292                     ParseGameHistory(parse);
3293 #if ZIPPY
3294                     if (appData.zippyPlay && first.initDone) {
3295                         FeedMovesToProgram(&first, forwardMostMove);
3296                         if (gameMode == IcsPlayingWhite) {
3297                             if (WhiteOnMove(forwardMostMove)) {
3298                                 if (first.sendTime) {
3299                                   if (first.useColors) {
3300                                     SendToProgram("black\n", &first);
3301                                   }
3302                                   SendTimeRemaining(&first, TRUE);
3303                                 }
3304                                 if (first.useColors) {
3305                                   SendToProgram("white\n", &first); // [HGM] book: made sending of "go\n" book dependent
3306                                 }
3307                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: probe book for initial pos
3308                                 first.maybeThinking = TRUE;
3309                             } else {
3310                                 if (first.usePlayother) {
3311                                   if (first.sendTime) {
3312                                     SendTimeRemaining(&first, TRUE);
3313                                   }
3314                                   SendToProgram("playother\n", &first);
3315                                   firstMove = FALSE;
3316                                 } else {
3317                                   firstMove = TRUE;
3318                                 }
3319                             }
3320                         } else if (gameMode == IcsPlayingBlack) {
3321                             if (!WhiteOnMove(forwardMostMove)) {
3322                                 if (first.sendTime) {
3323                                   if (first.useColors) {
3324                                     SendToProgram("white\n", &first);
3325                                   }
3326                                   SendTimeRemaining(&first, FALSE);
3327                                 }
3328                                 if (first.useColors) {
3329                                   SendToProgram("black\n", &first);
3330                                 }
3331                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE);
3332                                 first.maybeThinking = TRUE;
3333                             } else {
3334                                 if (first.usePlayother) {
3335                                   if (first.sendTime) {
3336                                     SendTimeRemaining(&first, FALSE);
3337                                   }
3338                                   SendToProgram("playother\n", &first);
3339                                   firstMove = FALSE;
3340                                 } else {
3341                                   firstMove = TRUE;
3342                                 }
3343                             }
3344                         }
3345                     }
3346 #endif
3347                     if (gameMode == IcsObserving && ics_gamenum == -1) {
3348                         /* Moves came from oldmoves or moves command
3349                            while we weren't doing anything else.
3350                            */
3351                         currentMove = forwardMostMove;
3352                         ClearHighlights();/*!!could figure this out*/
3353                         flipView = appData.flipView;
3354                         DrawPosition(TRUE, boards[currentMove]);
3355                         DisplayBothClocks();
3356                         snprintf(str, MSG_SIZ, "%s vs. %s",
3357                                 gameInfo.white, gameInfo.black);
3358                         DisplayTitle(str);
3359                         gameMode = IcsIdle;
3360                     } else {
3361                         /* Moves were history of an active game */
3362                         if (gameInfo.resultDetails != NULL) {
3363                             free(gameInfo.resultDetails);
3364                             gameInfo.resultDetails = NULL;
3365                         }
3366                     }
3367                     HistorySet(parseList, backwardMostMove,
3368                                forwardMostMove, currentMove-1);
3369                     DisplayMove(currentMove - 1);
3370                     if (started == STARTED_MOVES) next_out = i;
3371                     started = STARTED_NONE;
3372                     ics_getting_history = H_FALSE;
3373                     break;
3374
3375                   case STARTED_OBSERVE:
3376                     started = STARTED_NONE;
3377                     SendToICS(ics_prefix);
3378                     SendToICS("refresh\n");
3379                     break;
3380
3381                   default:
3382                     break;
3383                 }
3384                 if(bookHit) { // [HGM] book: simulate book reply
3385                     static char bookMove[MSG_SIZ]; // a bit generous?
3386
3387                     programStats.nodes = programStats.depth = programStats.time =
3388                     programStats.score = programStats.got_only_move = 0;
3389                     sprintf(programStats.movelist, "%s (xbook)", bookHit);
3390
3391                     safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
3392                     strcat(bookMove, bookHit);
3393                     HandleMachineMove(bookMove, &first);
3394                 }
3395                 continue;
3396             }
3397
3398             if ((started == STARTED_MOVES || started == STARTED_BOARD ||
3399                  started == STARTED_HOLDINGS ||
3400                  started == STARTED_MOVES_NOHIDE) && i >= leftover_len) {
3401                 /* Accumulate characters in move list or board */
3402                 parse[parse_pos++] = buf[i];
3403             }
3404
3405             /* Start of game messages.  Mostly we detect start of game
3406                when the first board image arrives.  On some versions
3407                of the ICS, though, we need to do a "refresh" after starting
3408                to observe in order to get the current board right away. */
3409             if (looking_at(buf, &i, "Adding game * to observation list")) {
3410                 started = STARTED_OBSERVE;
3411                 continue;
3412             }
3413
3414             /* Handle auto-observe */
3415             if (appData.autoObserve &&
3416                 (gameMode == IcsIdle || gameMode == BeginningOfGame) &&
3417                 looking_at(buf, &i, "Game notification: * (*) vs. * (*)")) {
3418                 char *player;
3419                 /* Choose the player that was highlighted, if any. */
3420                 if (star_match[0][0] == '\033' ||
3421                     star_match[1][0] != '\033') {
3422                     player = star_match[0];
3423                 } else {
3424                     player = star_match[2];
3425                 }
3426                 snprintf(str, MSG_SIZ, "%sobserve %s\n",
3427                         ics_prefix, StripHighlightAndTitle(player));
3428                 SendToICS(str);
3429
3430                 /* Save ratings from notify string */
3431                 safeStrCpy(player1Name, star_match[0], sizeof(player1Name)/sizeof(player1Name[0]));
3432                 player1Rating = string_to_rating(star_match[1]);
3433                 safeStrCpy(player2Name, star_match[2], sizeof(player2Name)/sizeof(player2Name[0]));
3434                 player2Rating = string_to_rating(star_match[3]);
3435
3436                 if (appData.debugMode)
3437                   fprintf(debugFP,
3438                           "Ratings from 'Game notification:' %s %d, %s %d\n",
3439                           player1Name, player1Rating,
3440                           player2Name, player2Rating);
3441
3442                 continue;
3443             }
3444
3445             /* Deal with automatic examine mode after a game,
3446                and with IcsObserving -> IcsExamining transition */
3447             if (looking_at(buf, &i, "Entering examine mode for game *") ||
3448                 looking_at(buf, &i, "has made you an examiner of game *")) {
3449
3450                 int gamenum = atoi(star_match[0]);
3451                 if ((gameMode == IcsIdle || gameMode == IcsObserving) &&
3452                     gamenum == ics_gamenum) {
3453                     /* We were already playing or observing this game;
3454                        no need to refetch history */
3455                     gameMode = IcsExamining;
3456                     if (pausing) {
3457                         pauseExamForwardMostMove = forwardMostMove;
3458                     } else if (currentMove < forwardMostMove) {
3459                         ForwardInner(forwardMostMove);
3460                     }
3461                 } else {
3462                     /* I don't think this case really can happen */
3463                     SendToICS(ics_prefix);
3464                     SendToICS("refresh\n");
3465                 }
3466                 continue;
3467             }
3468
3469             /* Error messages */
3470 //          if (ics_user_moved) {
3471             if (1) { // [HGM] old way ignored error after move type in; ics_user_moved is not set then!
3472                 if (looking_at(buf, &i, "Illegal move") ||
3473                     looking_at(buf, &i, "Not a legal move") ||
3474                     looking_at(buf, &i, "Your king is in check") ||
3475                     looking_at(buf, &i, "It isn't your turn") ||
3476                     looking_at(buf, &i, "It is not your move")) {
3477                     /* Illegal move */
3478                     if (ics_user_moved && forwardMostMove > backwardMostMove) { // only backup if we already moved
3479                         currentMove = forwardMostMove-1;
3480                         DisplayMove(currentMove - 1); /* before DMError */
3481                         DrawPosition(FALSE, boards[currentMove]);
3482                         SwitchClocks(forwardMostMove-1); // [HGM] race
3483                         DisplayBothClocks();
3484                     }
3485                     DisplayMoveError(_("Illegal move (rejected by ICS)")); // [HGM] but always relay error msg
3486                     ics_user_moved = 0;
3487                     continue;
3488                 }
3489             }
3490
3491             if (looking_at(buf, &i, "still have time") ||
3492                 looking_at(buf, &i, "not out of time") ||
3493                 looking_at(buf, &i, "either player is out of time") ||
3494                 looking_at(buf, &i, "has timeseal; checking")) {
3495                 /* We must have called his flag a little too soon */
3496                 whiteFlag = blackFlag = FALSE;
3497                 continue;
3498             }
3499
3500             if (looking_at(buf, &i, "added * seconds to") ||
3501                 looking_at(buf, &i, "seconds were added to")) {
3502                 /* Update the clocks */
3503                 SendToICS(ics_prefix);
3504                 SendToICS("refresh\n");
3505                 continue;
3506             }
3507
3508             if (!ics_clock_paused && looking_at(buf, &i, "clock paused")) {
3509                 ics_clock_paused = TRUE;
3510                 StopClocks();
3511                 continue;
3512             }
3513
3514             if (ics_clock_paused && looking_at(buf, &i, "clock resumed")) {
3515                 ics_clock_paused = FALSE;
3516                 StartClocks();
3517                 continue;
3518             }
3519
3520             /* Grab player ratings from the Creating: message.
3521                Note we have to check for the special case when
3522                the ICS inserts things like [white] or [black]. */
3523             if (looking_at(buf, &i, "Creating: * (*)* * (*)") ||
3524                 looking_at(buf, &i, "Creating: * (*) [*] * (*)")) {
3525                 /* star_matches:
3526                    0    player 1 name (not necessarily white)
3527                    1    player 1 rating
3528                    2    empty, white, or black (IGNORED)
3529                    3    player 2 name (not necessarily black)
3530                    4    player 2 rating
3531
3532                    The names/ratings are sorted out when the game
3533                    actually starts (below).
3534                 */
3535                 safeStrCpy(player1Name, StripHighlightAndTitle(star_match[0]), sizeof(player1Name)/sizeof(player1Name[0]));
3536                 player1Rating = string_to_rating(star_match[1]);
3537                 safeStrCpy(player2Name, StripHighlightAndTitle(star_match[3]), sizeof(player2Name)/sizeof(player2Name[0]));
3538                 player2Rating = string_to_rating(star_match[4]);
3539
3540                 if (appData.debugMode)
3541                   fprintf(debugFP,
3542                           "Ratings from 'Creating:' %s %d, %s %d\n",
3543                           player1Name, player1Rating,
3544                           player2Name, player2Rating);
3545
3546                 continue;
3547             }
3548
3549             /* Improved generic start/end-of-game messages */
3550             if ((tkind=0, looking_at(buf, &i, "{Game * (* vs. *) *}*")) ||
3551                 (tkind=1, looking_at(buf, &i, "{Game * (*(*) vs. *(*)) *}*"))){
3552                 /* If tkind == 0: */
3553                 /* star_match[0] is the game number */
3554                 /*           [1] is the white player's name */
3555                 /*           [2] is the black player's name */
3556                 /* For end-of-game: */
3557                 /*           [3] is the reason for the game end */
3558                 /*           [4] is a PGN end game-token, preceded by " " */
3559                 /* For start-of-game: */
3560                 /*           [3] begins with "Creating" or "Continuing" */
3561                 /*           [4] is " *" or empty (don't care). */
3562                 int gamenum = atoi(star_match[0]);
3563                 char *whitename, *blackname, *why, *endtoken;
3564                 ChessMove endtype = EndOfFile;
3565
3566                 if (tkind == 0) {
3567                   whitename = star_match[1];
3568                   blackname = star_match[2];
3569                   why = star_match[3];
3570                   endtoken = star_match[4];
3571                 } else {
3572                   whitename = star_match[1];
3573                   blackname = star_match[3];
3574                   why = star_match[5];
3575                   endtoken = star_match[6];
3576                 }
3577
3578                 /* Game start messages */
3579                 if (strncmp(why, "Creating ", 9) == 0 ||
3580                     strncmp(why, "Continuing ", 11) == 0) {
3581                     gs_gamenum = gamenum;
3582                     safeStrCpy(gs_kind, strchr(why, ' ') + 1,sizeof(gs_kind)/sizeof(gs_kind[0]));
3583                     VariantSwitch(boards[currentMove], StringToVariant(gs_kind)); // [HGM] variantswitch: even before we get first board
3584 #if ZIPPY
3585                     if (appData.zippyPlay) {
3586                         ZippyGameStart(whitename, blackname);
3587                     }
3588 #endif /*ZIPPY*/
3589                     partnerBoardValid = FALSE; // [HGM] bughouse
3590                     continue;
3591                 }
3592
3593                 /* Game end messages */
3594                 if (gameMode == IcsIdle || gameMode == BeginningOfGame ||
3595                     ics_gamenum != gamenum) {
3596                     continue;
3597                 }
3598                 while (endtoken[0] == ' ') endtoken++;
3599                 switch (endtoken[0]) {
3600                   case '*':
3601                   default:
3602                     endtype = GameUnfinished;
3603                     break;
3604                   case '0':
3605                     endtype = BlackWins;
3606                     break;
3607                   case '1':
3608                     if (endtoken[1] == '/')
3609                       endtype = GameIsDrawn;
3610                     else
3611                       endtype = WhiteWins;
3612                     break;
3613                 }
3614                 GameEnds(endtype, why, GE_ICS);
3615 #if ZIPPY
3616                 if (appData.zippyPlay && first.initDone) {
3617                     ZippyGameEnd(endtype, why);
3618                     if (first.pr == NULL) {
3619                       /* Start the next process early so that we'll
3620                          be ready for the next challenge */
3621                       StartChessProgram(&first);
3622                     }
3623                     /* Send "new" early, in case this command takes
3624                        a long time to finish, so that we'll be ready
3625                        for the next challenge. */
3626                     gameInfo.variant = VariantNormal; // [HGM] variantswitch: suppress sending of 'variant'
3627                     Reset(TRUE, TRUE);
3628                 }
3629 #endif /*ZIPPY*/
3630                 if(appData.bgObserve && partnerBoardValid) DrawPosition(TRUE, partnerBoard);
3631                 continue;
3632             }
3633
3634             if (looking_at(buf, &i, "Removing game * from observation") ||
3635                 looking_at(buf, &i, "no longer observing game *") ||
3636                 looking_at(buf, &i, "Game * (*) has no examiners")) {
3637                 if (gameMode == IcsObserving &&
3638                     atoi(star_match[0]) == ics_gamenum)
3639                   {
3640                       /* icsEngineAnalyze */
3641                       if (appData.icsEngineAnalyze) {
3642                             ExitAnalyzeMode();
3643                             ModeHighlight();
3644                       }
3645                       StopClocks();
3646                       gameMode = IcsIdle;
3647                       ics_gamenum = -1;
3648                       ics_user_moved = FALSE;
3649                   }
3650                 continue;
3651             }
3652
3653             if (looking_at(buf, &i, "no longer examining game *")) {
3654                 if (gameMode == IcsExamining &&
3655                     atoi(star_match[0]) == ics_gamenum)
3656                   {
3657                       gameMode = IcsIdle;
3658                       ics_gamenum = -1;
3659                       ics_user_moved = FALSE;
3660                   }
3661                 continue;
3662             }
3663
3664             /* Advance leftover_start past any newlines we find,
3665                so only partial lines can get reparsed */
3666             if (looking_at(buf, &i, "\n")) {
3667                 prevColor = curColor;
3668                 if (curColor != ColorNormal) {
3669                     if (oldi > next_out) {
3670                         SendToPlayer(&buf[next_out], oldi - next_out);
3671                         next_out = oldi;
3672                     }
3673                     Colorize(ColorNormal, FALSE);
3674                     curColor = ColorNormal;
3675                 }
3676                 if (started == STARTED_BOARD) {
3677                     started = STARTED_NONE;
3678                     parse[parse_pos] = NULLCHAR;
3679                     ParseBoard12(parse);
3680                     ics_user_moved = 0;
3681
3682                     /* Send premove here */
3683                     if (appData.premove) {
3684                       char str[MSG_SIZ];
3685                       if (currentMove == 0 &&
3686                           gameMode == IcsPlayingWhite &&
3687                           appData.premoveWhite) {
3688                         snprintf(str, MSG_SIZ, "%s\n", appData.premoveWhiteText);
3689                         if (appData.debugMode)
3690                           fprintf(debugFP, "Sending premove:\n");
3691                         SendToICS(str);
3692                       } else if (currentMove == 1 &&
3693                                  gameMode == IcsPlayingBlack &&
3694                                  appData.premoveBlack) {
3695                         snprintf(str, MSG_SIZ, "%s\n", appData.premoveBlackText);
3696                         if (appData.debugMode)
3697                           fprintf(debugFP, "Sending premove:\n");
3698                         SendToICS(str);
3699                       } else if (gotPremove) {
3700                         gotPremove = 0;
3701                         ClearPremoveHighlights();
3702                         if (appData.debugMode)
3703                           fprintf(debugFP, "Sending premove:\n");
3704                           UserMoveEvent(premoveFromX, premoveFromY,
3705                                         premoveToX, premoveToY,
3706                                         premovePromoChar);
3707                       }
3708                     }
3709
3710                     /* Usually suppress following prompt */
3711                     if (!(forwardMostMove == 0 && gameMode == IcsExamining)) {
3712                         while(looking_at(buf, &i, "\n")); // [HGM] skip empty lines
3713                         if (looking_at(buf, &i, "*% ")) {
3714                             savingComment = FALSE;
3715                             suppressKibitz = 0;
3716                         }
3717                     }
3718                     next_out = i;
3719                 } else if (started == STARTED_HOLDINGS) {
3720                     int gamenum;
3721                     char new_piece[MSG_SIZ];
3722                     started = STARTED_NONE;
3723                     parse[parse_pos] = NULLCHAR;
3724                     if (appData.debugMode)
3725                       fprintf(debugFP, "Parsing holdings: %s, currentMove = %d\n",
3726                                                         parse, currentMove);
3727                     if (sscanf(parse, " game %d", &gamenum) == 1) {
3728                       if(gamenum == ics_gamenum) { // [HGM] bughouse: old code if part of foreground game
3729                         if (gameInfo.variant == VariantNormal) {
3730                           /* [HGM] We seem to switch variant during a game!
3731                            * Presumably no holdings were displayed, so we have
3732                            * to move the position two files to the right to
3733                            * create room for them!
3734                            */
3735                           VariantClass newVariant;
3736                           switch(gameInfo.boardWidth) { // base guess on board width
3737                                 case 9:  newVariant = VariantShogi; break;
3738                                 case 10: newVariant = VariantGreat; break;
3739                                 default: newVariant = VariantCrazyhouse; break;
3740                           }
3741                           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
3742                           /* Get a move list just to see the header, which
3743                              will tell us whether this is really bug or zh */
3744                           if (ics_getting_history == H_FALSE) {
3745                             ics_getting_history = H_REQUESTED;
3746                             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
3747                             SendToICS(str);
3748                           }
3749                         }
3750                         new_piece[0] = NULLCHAR;
3751                         sscanf(parse, "game %d white [%s black [%s <- %s",
3752                                &gamenum, white_holding, black_holding,
3753                                new_piece);
3754                         white_holding[strlen(white_holding)-1] = NULLCHAR;
3755                         black_holding[strlen(black_holding)-1] = NULLCHAR;
3756                         /* [HGM] copy holdings to board holdings area */
3757                         CopyHoldings(boards[forwardMostMove], white_holding, WhitePawn);
3758                         CopyHoldings(boards[forwardMostMove], black_holding, BlackPawn);
3759                         boards[forwardMostMove][HOLDINGS_SET] = 1; // flag holdings as set
3760 #if ZIPPY
3761                         if (appData.zippyPlay && first.initDone) {
3762                             ZippyHoldings(white_holding, black_holding,
3763                                           new_piece);
3764                         }
3765 #endif /*ZIPPY*/
3766                         if (tinyLayout || smallLayout) {
3767                             char wh[16], bh[16];
3768                             PackHolding(wh, white_holding);
3769                             PackHolding(bh, black_holding);
3770                             snprintf(str, MSG_SIZ,"[%s-%s] %s-%s", wh, bh,
3771                                     gameInfo.white, gameInfo.black);
3772                         } else {
3773                           snprintf(str, MSG_SIZ, "%s [%s] vs. %s [%s]",
3774                                     gameInfo.white, white_holding,
3775                                     gameInfo.black, black_holding);
3776                         }
3777                         if(!partnerUp) // [HGM] bughouse: when peeking at partner game we already know what he captured...
3778                         DrawPosition(FALSE, boards[currentMove]);
3779                         DisplayTitle(str);
3780                       } else if(appData.bgObserve) { // [HGM] bughouse: holdings of other game => background
3781                         sscanf(parse, "game %d white [%s black [%s <- %s",
3782                                &gamenum, white_holding, black_holding,
3783                                new_piece);
3784                         white_holding[strlen(white_holding)-1] = NULLCHAR;
3785                         black_holding[strlen(black_holding)-1] = NULLCHAR;
3786                         /* [HGM] copy holdings to partner-board holdings area */
3787                         CopyHoldings(partnerBoard, white_holding, WhitePawn);
3788                         CopyHoldings(partnerBoard, black_holding, BlackPawn);
3789                         if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual: always draw
3790                         if(partnerUp) DrawPosition(FALSE, partnerBoard);
3791                         if(twoBoards) { partnerUp = 0; flipView = !flipView; }
3792                       }
3793                     }
3794                     /* Suppress following prompt */
3795                     if (looking_at(buf, &i, "*% ")) {
3796                         if(strchr(star_match[0], 7)) SendToPlayer("\007", 1); // Bell(); // FICS fuses bell for next board with prompt in zh captures
3797                         savingComment = FALSE;
3798                         suppressKibitz = 0;
3799                     }
3800                     next_out = i;
3801                 }
3802                 continue;
3803             }
3804
3805             i++;                /* skip unparsed character and loop back */
3806         }
3807
3808         if (started != STARTED_MOVES && started != STARTED_BOARD && !suppressKibitz && // [HGM] kibitz
3809 //          started != STARTED_HOLDINGS && i > next_out) { // [HGM] should we compare to leftover_start in stead of i?
3810 //          SendToPlayer(&buf[next_out], i - next_out);
3811             started != STARTED_HOLDINGS && leftover_start > next_out) {
3812             SendToPlayer(&buf[next_out], leftover_start - next_out);
3813             next_out = i;
3814         }
3815
3816         leftover_len = buf_len - leftover_start;
3817         /* if buffer ends with something we couldn't parse,
3818            reparse it after appending the next read */
3819
3820     } else if (count == 0) {
3821         RemoveInputSource(isr);
3822         DisplayFatalError(_("Connection closed by ICS"), 0, 0);
3823     } else {
3824         DisplayFatalError(_("Error reading from ICS"), error, 1);
3825     }
3826 }
3827
3828
3829 /* Board style 12 looks like this:
3830
3831    <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
3832
3833  * The "<12> " is stripped before it gets to this routine.  The two
3834  * trailing 0's (flip state and clock ticking) are later addition, and
3835  * some chess servers may not have them, or may have only the first.
3836  * Additional trailing fields may be added in the future.
3837  */
3838
3839 #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"
3840
3841 #define RELATION_OBSERVING_PLAYED    0
3842 #define RELATION_OBSERVING_STATIC   -2   /* examined, oldmoves, or smoves */
3843 #define RELATION_PLAYING_MYMOVE      1
3844 #define RELATION_PLAYING_NOTMYMOVE  -1
3845 #define RELATION_EXAMINING           2
3846 #define RELATION_ISOLATED_BOARD     -3
3847 #define RELATION_STARTING_POSITION  -4   /* FICS only */
3848
3849 void
3850 ParseBoard12(string)
3851      char *string;
3852 {
3853     GameMode newGameMode;
3854     int gamenum, newGame, newMove, relation, basetime, increment, ics_flip = 0, i;
3855     int j, k, n, moveNum, white_stren, black_stren, white_time, black_time, takeback;
3856     int double_push, castle_ws, castle_wl, castle_bs, castle_bl, irrev_count;
3857     char to_play, board_chars[200];
3858     char move_str[MSG_SIZ], str[MSG_SIZ], elapsed_time[MSG_SIZ];
3859     char black[32], white[32];
3860     Board board;
3861     int prevMove = currentMove;
3862     int ticking = 2;
3863     ChessMove moveType;
3864     int fromX, fromY, toX, toY;
3865     char promoChar;
3866     int ranks=1, files=0; /* [HGM] ICS80: allow variable board size */
3867     char *bookHit = NULL; // [HGM] book
3868     Boolean weird = FALSE, reqFlag = FALSE;
3869
3870     fromX = fromY = toX = toY = -1;
3871
3872     newGame = FALSE;
3873
3874     if (appData.debugMode)
3875       fprintf(debugFP, _("Parsing board: %s\n"), string);
3876
3877     move_str[0] = NULLCHAR;
3878     elapsed_time[0] = NULLCHAR;
3879     {   /* [HGM] figure out how many ranks and files the board has, for ICS extension used by Capablanca server */
3880         int  i = 0, j;
3881         while(i < 199 && (string[i] != ' ' || string[i+2] != ' ')) {
3882             if(string[i] == ' ') { ranks++; files = 0; }
3883             else files++;
3884             if(!strchr(" -pnbrqkPNBRQK" , string[i])) weird = TRUE; // test for fairies
3885             i++;
3886         }
3887         for(j = 0; j <i; j++) board_chars[j] = string[j];
3888         board_chars[i] = '\0';
3889         string += i + 1;
3890     }
3891     n = sscanf(string, PATTERN, &to_play, &double_push,
3892                &castle_ws, &castle_wl, &castle_bs, &castle_bl, &irrev_count,
3893                &gamenum, white, black, &relation, &basetime, &increment,
3894                &white_stren, &black_stren, &white_time, &black_time,
3895                &moveNum, str, elapsed_time, move_str, &ics_flip,
3896                &ticking);
3897
3898     if (n < 21) {
3899         snprintf(str, MSG_SIZ, _("Failed to parse board string:\n\"%s\""), string);
3900         DisplayError(str, 0);
3901         return;
3902     }
3903
3904     /* Convert the move number to internal form */
3905     moveNum = (moveNum - 1) * 2;
3906     if (to_play == 'B') moveNum++;
3907     if (moveNum > framePtr) { // [HGM] vari: do not run into saved variations
3908       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
3909                         0, 1);
3910       return;
3911     }
3912
3913     switch (relation) {
3914       case RELATION_OBSERVING_PLAYED:
3915       case RELATION_OBSERVING_STATIC:
3916         if (gamenum == -1) {
3917             /* Old ICC buglet */
3918             relation = RELATION_OBSERVING_STATIC;
3919         }
3920         newGameMode = IcsObserving;
3921         break;
3922       case RELATION_PLAYING_MYMOVE:
3923       case RELATION_PLAYING_NOTMYMOVE:
3924         newGameMode =
3925           ((relation == RELATION_PLAYING_MYMOVE) == (to_play == 'W')) ?
3926             IcsPlayingWhite : IcsPlayingBlack;
3927         break;
3928       case RELATION_EXAMINING:
3929         newGameMode = IcsExamining;
3930         break;
3931       case RELATION_ISOLATED_BOARD:
3932       default:
3933         /* Just display this board.  If user was doing something else,
3934            we will forget about it until the next board comes. */
3935         newGameMode = IcsIdle;
3936         break;
3937       case RELATION_STARTING_POSITION:
3938         newGameMode = gameMode;
3939         break;
3940     }
3941
3942     if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)
3943          && newGameMode == IcsObserving && gamenum != ics_gamenum && appData.bgObserve) {
3944       // [HGM] bughouse: don't act on alien boards while we play. Just parse the board and save it */
3945       char *toSqr;
3946       for (k = 0; k < ranks; k++) {
3947         for (j = 0; j < files; j++)
3948           board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
3949         if(gameInfo.holdingsWidth > 1) {
3950              board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
3951              board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
3952         }
3953       }
3954       CopyBoard(partnerBoard, board);
3955       if(toSqr = strchr(str, '/')) { // extract highlights from long move
3956         partnerBoard[EP_STATUS-3] = toSqr[1] - AAA; // kludge: hide highlighting info in board
3957         partnerBoard[EP_STATUS-4] = toSqr[2] - ONE;
3958       } else partnerBoard[EP_STATUS-4] = partnerBoard[EP_STATUS-3] = -1;
3959       if(toSqr = strchr(str, '-')) {
3960         partnerBoard[EP_STATUS-1] = toSqr[1] - AAA;
3961         partnerBoard[EP_STATUS-2] = toSqr[2] - ONE;
3962       } else partnerBoard[EP_STATUS-1] = partnerBoard[EP_STATUS-2] = -1;
3963       if(appData.dualBoard && !twoBoards) { twoBoards = 1; InitDrawingSizes(-2,0); }
3964       if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual
3965       if(partnerUp) DrawPosition(FALSE, partnerBoard);
3966       if(twoBoards) { partnerUp = 0; flipView = !flipView; } // [HGM] dual
3967       snprintf(partnerStatus, MSG_SIZ,"W: %d:%02d B: %d:%02d (%d-%d) %c", white_time/60000, (white_time%60000)/1000,
3968                  (black_time/60000), (black_time%60000)/1000, white_stren, black_stren, to_play);
3969       DisplayMessage(partnerStatus, "");
3970         partnerBoardValid = TRUE;
3971       return;
3972     }
3973
3974     /* Modify behavior for initial board display on move listing
3975        of wild games.
3976        */
3977     switch (ics_getting_history) {
3978       case H_FALSE:
3979       case H_REQUESTED:
3980         break;
3981       case H_GOT_REQ_HEADER:
3982       case H_GOT_UNREQ_HEADER:
3983         /* This is the initial position of the current game */
3984         gamenum = ics_gamenum;
3985         moveNum = 0;            /* old ICS bug workaround */
3986         if (to_play == 'B') {
3987           startedFromSetupPosition = TRUE;
3988           blackPlaysFirst = TRUE;
3989           moveNum = 1;
3990           if (forwardMostMove == 0) forwardMostMove = 1;
3991           if (backwardMostMove == 0) backwardMostMove = 1;
3992           if (currentMove == 0) currentMove = 1;
3993         }
3994         newGameMode = gameMode;
3995         relation = RELATION_STARTING_POSITION; /* ICC needs this */
3996         break;
3997       case H_GOT_UNWANTED_HEADER:
3998         /* This is an initial board that we don't want */
3999         return;
4000       case H_GETTING_MOVES:
4001         /* Should not happen */
4002         DisplayError(_("Error gathering move list: extra board"), 0);
4003         ics_getting_history = H_FALSE;
4004         return;
4005     }
4006
4007    if (gameInfo.boardHeight != ranks || gameInfo.boardWidth != files ||
4008                                         weird && (int)gameInfo.variant < (int)VariantShogi) {
4009      /* [HGM] We seem to have switched variant unexpectedly
4010       * Try to guess new variant from board size
4011       */
4012           VariantClass newVariant = VariantFairy; // if 8x8, but fairies present
4013           if(ranks == 8 && files == 10) newVariant = VariantCapablanca; else
4014           if(ranks == 10 && files == 9) newVariant = VariantXiangqi; else
4015           if(ranks == 8 && files == 12) newVariant = VariantCourier; else
4016           if(ranks == 9 && files == 9)  newVariant = VariantShogi; else
4017           if(!weird) newVariant = VariantNormal;
4018           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
4019           /* Get a move list just to see the header, which
4020              will tell us whether this is really bug or zh */
4021           if (ics_getting_history == H_FALSE) {
4022             ics_getting_history = H_REQUESTED; reqFlag = TRUE;
4023             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4024             SendToICS(str);
4025           }
4026     }
4027
4028     /* Take action if this is the first board of a new game, or of a
4029        different game than is currently being displayed.  */
4030     if (gamenum != ics_gamenum || newGameMode != gameMode ||
4031         relation == RELATION_ISOLATED_BOARD) {
4032
4033         /* Forget the old game and get the history (if any) of the new one */
4034         if (gameMode != BeginningOfGame) {
4035           Reset(TRUE, TRUE);
4036         }
4037         newGame = TRUE;
4038         if (appData.autoRaiseBoard) BoardToTop();
4039         prevMove = -3;
4040         if (gamenum == -1) {
4041             newGameMode = IcsIdle;
4042         } else if ((moveNum > 0 || newGameMode == IcsObserving) && newGameMode != IcsIdle &&
4043                    appData.getMoveList && !reqFlag) {
4044             /* Need to get game history */
4045             ics_getting_history = H_REQUESTED;
4046             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4047             SendToICS(str);
4048         }
4049
4050         /* Initially flip the board to have black on the bottom if playing
4051            black or if the ICS flip flag is set, but let the user change
4052            it with the Flip View button. */
4053         flipView = appData.autoFlipView ?
4054           (newGameMode == IcsPlayingBlack) || ics_flip :
4055           appData.flipView;
4056
4057         /* Done with values from previous mode; copy in new ones */
4058         gameMode = newGameMode;
4059         ModeHighlight();
4060         ics_gamenum = gamenum;
4061         if (gamenum == gs_gamenum) {
4062             int klen = strlen(gs_kind);
4063             if (gs_kind[klen - 1] == '.') gs_kind[klen - 1] = NULLCHAR;
4064             snprintf(str, MSG_SIZ, "ICS %s", gs_kind);
4065             gameInfo.event = StrSave(str);
4066         } else {
4067             gameInfo.event = StrSave("ICS game");
4068         }
4069         gameInfo.site = StrSave(appData.icsHost);
4070         gameInfo.date = PGNDate();
4071         gameInfo.round = StrSave("-");
4072         gameInfo.white = StrSave(white);
4073         gameInfo.black = StrSave(black);
4074         timeControl = basetime * 60 * 1000;
4075         timeControl_2 = 0;
4076         timeIncrement = increment * 1000;
4077         movesPerSession = 0;
4078         gameInfo.timeControl = TimeControlTagValue();
4079         VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event) );
4080   if (appData.debugMode) {
4081     fprintf(debugFP, "ParseBoard says variant = '%s'\n", gameInfo.event);
4082     fprintf(debugFP, "recognized as %s\n", VariantName(gameInfo.variant));
4083     setbuf(debugFP, NULL);
4084   }
4085
4086         gameInfo.outOfBook = NULL;
4087
4088         /* Do we have the ratings? */
4089         if (strcmp(player1Name, white) == 0 &&
4090             strcmp(player2Name, black) == 0) {
4091             if (appData.debugMode)
4092               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
4093                       player1Rating, player2Rating);
4094             gameInfo.whiteRating = player1Rating;
4095             gameInfo.blackRating = player2Rating;
4096         } else if (strcmp(player2Name, white) == 0 &&
4097                    strcmp(player1Name, black) == 0) {
4098             if (appData.debugMode)
4099               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
4100                       player2Rating, player1Rating);
4101             gameInfo.whiteRating = player2Rating;
4102             gameInfo.blackRating = player1Rating;
4103         }
4104         player1Name[0] = player2Name[0] = NULLCHAR;
4105
4106         /* Silence shouts if requested */
4107         if (appData.quietPlay &&
4108             (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)) {
4109             SendToICS(ics_prefix);
4110             SendToICS("set shout 0\n");
4111         }
4112     }
4113
4114     /* Deal with midgame name changes */
4115     if (!newGame) {
4116         if (!gameInfo.white || strcmp(gameInfo.white, white) != 0) {
4117             if (gameInfo.white) free(gameInfo.white);
4118             gameInfo.white = StrSave(white);
4119         }
4120         if (!gameInfo.black || strcmp(gameInfo.black, black) != 0) {
4121             if (gameInfo.black) free(gameInfo.black);
4122             gameInfo.black = StrSave(black);
4123         }
4124     }
4125
4126     /* Throw away game result if anything actually changes in examine mode */
4127     if (gameMode == IcsExamining && !newGame) {
4128         gameInfo.result = GameUnfinished;
4129         if (gameInfo.resultDetails != NULL) {
4130             free(gameInfo.resultDetails);
4131             gameInfo.resultDetails = NULL;
4132         }
4133     }
4134
4135     /* In pausing && IcsExamining mode, we ignore boards coming
4136        in if they are in a different variation than we are. */
4137     if (pauseExamInvalid) return;
4138     if (pausing && gameMode == IcsExamining) {
4139         if (moveNum <= pauseExamForwardMostMove) {
4140             pauseExamInvalid = TRUE;
4141             forwardMostMove = pauseExamForwardMostMove;
4142             return;
4143         }
4144     }
4145
4146   if (appData.debugMode) {
4147     fprintf(debugFP, "load %dx%d board\n", files, ranks);
4148   }
4149     /* Parse the board */
4150     for (k = 0; k < ranks; k++) {
4151       for (j = 0; j < files; j++)
4152         board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
4153       if(gameInfo.holdingsWidth > 1) {
4154            board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
4155            board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
4156       }
4157     }
4158     CopyBoard(boards[moveNum], board);
4159     boards[moveNum][HOLDINGS_SET] = 0; // [HGM] indicate holdings not set
4160     if (moveNum == 0) {
4161         startedFromSetupPosition =
4162           !CompareBoards(board, initialPosition);
4163         if(startedFromSetupPosition)
4164             initialRulePlies = irrev_count; /* [HGM] 50-move counter offset */
4165     }
4166
4167     /* [HGM] Set castling rights. Take the outermost Rooks,
4168        to make it also work for FRC opening positions. Note that board12
4169        is really defective for later FRC positions, as it has no way to
4170        indicate which Rook can castle if they are on the same side of King.
4171        For the initial position we grant rights to the outermost Rooks,
4172        and remember thos rights, and we then copy them on positions
4173        later in an FRC game. This means WB might not recognize castlings with
4174        Rooks that have moved back to their original position as illegal,
4175        but in ICS mode that is not its job anyway.
4176     */
4177     if(moveNum == 0 || gameInfo.variant != VariantFischeRandom)
4178     { int i, j; ChessSquare wKing = WhiteKing, bKing = BlackKing;
4179
4180         for(i=BOARD_LEFT, j=NoRights; i<BOARD_RGHT; i++)
4181             if(board[0][i] == WhiteRook) j = i;
4182         initialRights[0] = boards[moveNum][CASTLING][0] = (castle_ws == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4183         for(i=BOARD_RGHT-1, j=NoRights; i>=BOARD_LEFT; i--)
4184             if(board[0][i] == WhiteRook) j = i;
4185         initialRights[1] = boards[moveNum][CASTLING][1] = (castle_wl == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4186         for(i=BOARD_LEFT, j=NoRights; i<BOARD_RGHT; i++)
4187             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
4188         initialRights[3] = boards[moveNum][CASTLING][3] = (castle_bs == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4189         for(i=BOARD_RGHT-1, j=NoRights; i>=BOARD_LEFT; i--)
4190             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
4191         initialRights[4] = boards[moveNum][CASTLING][4] = (castle_bl == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4192
4193         if(gameInfo.variant == VariantKnightmate) { wKing = WhiteUnicorn; bKing = BlackUnicorn; }
4194         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
4195             if(board[0][k] == wKing) initialRights[2] = boards[moveNum][CASTLING][2] = k;
4196         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
4197             if(board[BOARD_HEIGHT-1][k] == bKing)
4198                 initialRights[5] = boards[moveNum][CASTLING][5] = k;
4199         if(gameInfo.variant == VariantTwoKings) {
4200             // In TwoKings looking for a King does not work, so always give castling rights to a King on e1/e8
4201             if(board[0][4] == wKing) initialRights[2] = boards[moveNum][CASTLING][2] = 4;
4202             if(board[BOARD_HEIGHT-1][4] == bKing) initialRights[5] = boards[moveNum][CASTLING][5] = 4;
4203         }
4204     } else { int r;
4205         r = boards[moveNum][CASTLING][0] = initialRights[0];
4206         if(board[0][r] != WhiteRook) boards[moveNum][CASTLING][0] = NoRights;
4207         r = boards[moveNum][CASTLING][1] = initialRights[1];
4208         if(board[0][r] != WhiteRook) boards[moveNum][CASTLING][1] = NoRights;
4209         r = boards[moveNum][CASTLING][3] = initialRights[3];
4210         if(board[BOARD_HEIGHT-1][r] != BlackRook) boards[moveNum][CASTLING][3] = NoRights;
4211         r = boards[moveNum][CASTLING][4] = initialRights[4];
4212         if(board[BOARD_HEIGHT-1][r] != BlackRook) boards[moveNum][CASTLING][4] = NoRights;
4213         /* wildcastle kludge: always assume King has rights */
4214         r = boards[moveNum][CASTLING][2] = initialRights[2];
4215         r = boards[moveNum][CASTLING][5] = initialRights[5];
4216     }
4217     /* [HGM] e.p. rights. Assume that ICS sends file number here? */
4218     boards[moveNum][EP_STATUS] = double_push == -1 ? EP_NONE : double_push + BOARD_LEFT;
4219
4220
4221     if (ics_getting_history == H_GOT_REQ_HEADER ||
4222         ics_getting_history == H_GOT_UNREQ_HEADER) {
4223         /* This was an initial position from a move list, not
4224            the current position */
4225         return;
4226     }
4227
4228     /* Update currentMove and known move number limits */
4229     newMove = newGame || moveNum > forwardMostMove;
4230
4231     if (newGame) {
4232         forwardMostMove = backwardMostMove = currentMove = moveNum;
4233         if (gameMode == IcsExamining && moveNum == 0) {
4234           /* Workaround for ICS limitation: we are not told the wild
4235              type when starting to examine a game.  But if we ask for
4236              the move list, the move list header will tell us */
4237             ics_getting_history = H_REQUESTED;
4238             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4239             SendToICS(str);
4240         }
4241     } else if (moveNum == forwardMostMove + 1 || moveNum == forwardMostMove
4242                || (moveNum < forwardMostMove && moveNum >= backwardMostMove)) {
4243 #if ZIPPY
4244         /* [DM] If we found takebacks during icsEngineAnalyze try send to engine */
4245         /* [HGM] applied this also to an engine that is silently watching        */
4246         if (appData.zippyPlay && moveNum < forwardMostMove && first.initDone &&
4247             (gameMode == IcsObserving || gameMode == IcsExamining) &&
4248             gameInfo.variant == currentlyInitializedVariant) {
4249           takeback = forwardMostMove - moveNum;
4250           for (i = 0; i < takeback; i++) {
4251             if (appData.debugMode) fprintf(debugFP, "take back move\n");
4252             SendToProgram("undo\n", &first);
4253           }
4254         }
4255 #endif
4256
4257         forwardMostMove = moveNum;
4258         if (!pausing || currentMove > forwardMostMove)
4259           currentMove = forwardMostMove;
4260     } else {
4261         /* New part of history that is not contiguous with old part */
4262         if (pausing && gameMode == IcsExamining) {
4263             pauseExamInvalid = TRUE;
4264             forwardMostMove = pauseExamForwardMostMove;
4265             return;
4266         }
4267         if (gameMode == IcsExamining && moveNum > 0 && appData.getMoveList) {
4268 #if ZIPPY
4269             if(appData.zippyPlay && forwardMostMove > 0 && first.initDone) {
4270                 // [HGM] when we will receive the move list we now request, it will be
4271                 // fed to the engine from the first move on. So if the engine is not
4272                 // in the initial position now, bring it there.
4273                 InitChessProgram(&first, 0);
4274             }
4275 #endif
4276             ics_getting_history = H_REQUESTED;
4277             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4278             SendToICS(str);
4279         }
4280         forwardMostMove = backwardMostMove = currentMove = moveNum;
4281     }
4282
4283     /* Update the clocks */
4284     if (strchr(elapsed_time, '.')) {
4285       /* Time is in ms */
4286       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time;
4287       timeRemaining[1][moveNum] = blackTimeRemaining = black_time;
4288     } else {
4289       /* Time is in seconds */
4290       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time * 1000;
4291       timeRemaining[1][moveNum] = blackTimeRemaining = black_time * 1000;
4292     }
4293
4294
4295 #if ZIPPY
4296     if (appData.zippyPlay && newGame &&
4297         gameMode != IcsObserving && gameMode != IcsIdle &&
4298         gameMode != IcsExamining)
4299       ZippyFirstBoard(moveNum, basetime, increment);
4300 #endif
4301
4302     /* Put the move on the move list, first converting
4303        to canonical algebraic form. */
4304     if (moveNum > 0) {
4305   if (appData.debugMode) {
4306     if (appData.debugMode) { int f = forwardMostMove;
4307         fprintf(debugFP, "parseboard %d, castling = %d %d %d %d %d %d\n", f,
4308                 boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
4309                 boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
4310     }
4311     fprintf(debugFP, "accepted move %s from ICS, parse it.\n", move_str);
4312     fprintf(debugFP, "moveNum = %d\n", moveNum);
4313     fprintf(debugFP, "board = %d-%d x %d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT);
4314     setbuf(debugFP, NULL);
4315   }
4316         if (moveNum <= backwardMostMove) {
4317             /* We don't know what the board looked like before
4318                this move.  Punt. */
4319           safeStrCpy(parseList[moveNum - 1], move_str, sizeof(parseList[moveNum - 1])/sizeof(parseList[moveNum - 1][0]));
4320             strcat(parseList[moveNum - 1], " ");
4321             strcat(parseList[moveNum - 1], elapsed_time);
4322             moveList[moveNum - 1][0] = NULLCHAR;
4323         } else if (strcmp(move_str, "none") == 0) {
4324             // [HGM] long SAN: swapped order; test for 'none' before parsing move
4325             /* Again, we don't know what the board looked like;
4326                this is really the start of the game. */
4327             parseList[moveNum - 1][0] = NULLCHAR;
4328             moveList[moveNum - 1][0] = NULLCHAR;
4329             backwardMostMove = moveNum;
4330             startedFromSetupPosition = TRUE;
4331             fromX = fromY = toX = toY = -1;
4332         } else {
4333           // [HGM] long SAN: if legality-testing is off, disambiguation might not work or give wrong move.
4334           //                 So we parse the long-algebraic move string in stead of the SAN move
4335           int valid; char buf[MSG_SIZ], *prom;
4336
4337           if(gameInfo.variant == VariantShogi && !strchr(move_str, '=') && !strchr(move_str, '@'))
4338                 strcat(move_str, "="); // if ICS does not say 'promote' on non-drop, we defer.
4339           // str looks something like "Q/a1-a2"; kill the slash
4340           if(str[1] == '/')
4341             snprintf(buf, MSG_SIZ,"%c%s", str[0], str+2);
4342           else  safeStrCpy(buf, str, sizeof(buf)/sizeof(buf[0])); // might be castling
4343           if((prom = strstr(move_str, "=")) && !strstr(buf, "="))
4344                 strcat(buf, prom); // long move lacks promo specification!
4345           if(!appData.testLegality && move_str[1] != '@') { // drops never ambiguous (parser chokes on long form!)
4346                 if(appData.debugMode)
4347                         fprintf(debugFP, "replaced ICS move '%s' by '%s'\n", move_str, buf);
4348                 safeStrCpy(move_str, buf, MSG_SIZ);
4349           }
4350           valid = ParseOneMove(move_str, moveNum - 1, &moveType,
4351                                 &fromX, &fromY, &toX, &toY, &promoChar)
4352                || ParseOneMove(buf, moveNum - 1, &moveType,
4353                                 &fromX, &fromY, &toX, &toY, &promoChar);
4354           // end of long SAN patch
4355           if (valid) {
4356             (void) CoordsToAlgebraic(boards[moveNum - 1],
4357                                      PosFlags(moveNum - 1),
4358                                      fromY, fromX, toY, toX, promoChar,
4359                                      parseList[moveNum-1]);
4360             switch (MateTest(boards[moveNum], PosFlags(moveNum)) ) {
4361               case MT_NONE:
4362               case MT_STALEMATE:
4363               default:
4364                 break;
4365               case MT_CHECK:
4366                 if(gameInfo.variant != VariantShogi)
4367                     strcat(parseList[moveNum - 1], "+");
4368                 break;
4369               case MT_CHECKMATE:
4370               case MT_STAINMATE: // [HGM] xq: for notation stalemate that wins counts as checkmate
4371                 strcat(parseList[moveNum - 1], "#");
4372                 break;
4373             }
4374             strcat(parseList[moveNum - 1], " ");
4375             strcat(parseList[moveNum - 1], elapsed_time);
4376             /* currentMoveString is set as a side-effect of ParseOneMove */
4377             if(gameInfo.variant == VariantShogi && currentMoveString[4]) currentMoveString[4] = '^';
4378             safeStrCpy(moveList[moveNum - 1], currentMoveString, sizeof(moveList[moveNum - 1])/sizeof(moveList[moveNum - 1][0]));
4379             strcat(moveList[moveNum - 1], "\n");
4380
4381             if(gameInfo.holdingsWidth && !appData.disguise) // inherit info that ICS does not give from previous board
4382               for(k=0; k<ranks; k++) for(j=BOARD_LEFT; j<BOARD_RGHT; j++) {
4383                 ChessSquare old, new = boards[moveNum][k][j];
4384                   if(fromY == DROP_RANK && k==toY && j==toX) continue; // dropped pieces always stand for themselves
4385                   old = (k==toY && j==toX) ? boards[moveNum-1][fromY][fromX] : boards[moveNum-1][k][j]; // trace back mover
4386                   if(old == new) continue;
4387                   if(old == PROMOTED new) boards[moveNum][k][j] = old; // prevent promoted pieces to revert to primordial ones
4388                   else if(new == WhiteWazir || new == BlackWazir) {
4389                       if(old < WhiteCannon || old >= BlackPawn && old < BlackCannon)
4390                            boards[moveNum][k][j] = PROMOTED old; // choose correct type of Gold in promotion
4391                       else boards[moveNum][k][j] = old; // preserve type of Gold
4392                   } else if((old == WhitePawn || old == BlackPawn) && new != EmptySquare) // Pawn promotions (but not e.p.capture!)
4393                       boards[moveNum][k][j] = PROMOTED new; // use non-primordial representation of chosen piece
4394               }
4395           } else {
4396             /* Move from ICS was illegal!?  Punt. */
4397             if (appData.debugMode) {
4398               fprintf(debugFP, "Illegal move from ICS '%s'\n", move_str);
4399               fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
4400             }
4401             safeStrCpy(parseList[moveNum - 1], move_str, sizeof(parseList[moveNum - 1])/sizeof(parseList[moveNum - 1][0]));
4402             strcat(parseList[moveNum - 1], " ");
4403             strcat(parseList[moveNum - 1], elapsed_time);
4404             moveList[moveNum - 1][0] = NULLCHAR;
4405             fromX = fromY = toX = toY = -1;
4406           }
4407         }
4408   if (appData.debugMode) {
4409     fprintf(debugFP, "Move parsed to '%s'\n", parseList[moveNum - 1]);
4410     setbuf(debugFP, NULL);
4411   }
4412
4413 #if ZIPPY
4414         /* Send move to chess program (BEFORE animating it). */
4415         if (appData.zippyPlay && !newGame && newMove &&
4416            (!appData.getMoveList || backwardMostMove == 0) && first.initDone) {
4417
4418             if ((gameMode == IcsPlayingWhite && WhiteOnMove(moveNum)) ||
4419                 (gameMode == IcsPlayingBlack && !WhiteOnMove(moveNum))) {
4420                 if (moveList[moveNum - 1][0] == NULLCHAR) {
4421                   snprintf(str, MSG_SIZ, _("Couldn't parse move \"%s\" from ICS"),
4422                             move_str);
4423                     DisplayError(str, 0);
4424                 } else {
4425                     if (first.sendTime) {
4426                         SendTimeRemaining(&first, gameMode == IcsPlayingWhite);
4427                     }
4428                     bookHit = SendMoveToBookUser(moveNum - 1, &first, FALSE); // [HGM] book
4429                     if (firstMove && !bookHit) {
4430                         firstMove = FALSE;
4431                         if (first.useColors) {
4432                           SendToProgram(gameMode == IcsPlayingWhite ?
4433                                         "white\ngo\n" :
4434                                         "black\ngo\n", &first);
4435                         } else {
4436                           SendToProgram("go\n", &first);
4437                         }
4438                         first.maybeThinking = TRUE;
4439                     }
4440                 }
4441             } else if (gameMode == IcsObserving || gameMode == IcsExamining) {
4442               if (moveList[moveNum - 1][0] == NULLCHAR) {
4443                 snprintf(str, MSG_SIZ, _("Couldn't parse move \"%s\" from ICS"), move_str);
4444                 DisplayError(str, 0);
4445               } else {
4446                 if(gameInfo.variant == currentlyInitializedVariant) // [HGM] refrain sending moves engine can't understand!
4447                 SendMoveToProgram(moveNum - 1, &first);
4448               }
4449             }
4450         }
4451 #endif
4452     }
4453
4454     if (moveNum > 0 && !gotPremove && !appData.noGUI) {
4455         /* If move comes from a remote source, animate it.  If it
4456            isn't remote, it will have already been animated. */
4457         if (!pausing && !ics_user_moved && prevMove == moveNum - 1) {
4458             AnimateMove(boards[moveNum - 1], fromX, fromY, toX, toY);
4459         }
4460         if (!pausing && appData.highlightLastMove) {
4461             SetHighlights(fromX, fromY, toX, toY);
4462         }
4463     }
4464
4465     /* Start the clocks */
4466     whiteFlag = blackFlag = FALSE;
4467     appData.clockMode = !(basetime == 0 && increment == 0);
4468     if (ticking == 0) {
4469       ics_clock_paused = TRUE;
4470       StopClocks();
4471     } else if (ticking == 1) {
4472       ics_clock_paused = FALSE;
4473     }
4474     if (gameMode == IcsIdle ||
4475         relation == RELATION_OBSERVING_STATIC ||
4476         relation == RELATION_EXAMINING ||
4477         ics_clock_paused)
4478       DisplayBothClocks();
4479     else
4480       StartClocks();
4481
4482     /* Display opponents and material strengths */
4483     if (gameInfo.variant != VariantBughouse &&
4484         gameInfo.variant != VariantCrazyhouse && !appData.noGUI) {
4485         if (tinyLayout || smallLayout) {
4486             if(gameInfo.variant == VariantNormal)
4487               snprintf(str, MSG_SIZ, "%s(%d) %s(%d) {%d %d}",
4488                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4489                     basetime, increment);
4490             else
4491               snprintf(str, MSG_SIZ, "%s(%d) %s(%d) {%d %d w%d}",
4492                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4493                     basetime, increment, (int) gameInfo.variant);
4494         } else {
4495             if(gameInfo.variant == VariantNormal)
4496               snprintf(str, MSG_SIZ, "%s (%d) vs. %s (%d) {%d %d}",
4497                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4498                     basetime, increment);
4499             else
4500               snprintf(str, MSG_SIZ, "%s (%d) vs. %s (%d) {%d %d %s}",
4501                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4502                     basetime, increment, VariantName(gameInfo.variant));
4503         }
4504         DisplayTitle(str);
4505   if (appData.debugMode) {
4506     fprintf(debugFP, "Display title '%s, gameInfo.variant = %d'\n", str, gameInfo.variant);
4507   }
4508     }
4509
4510
4511     /* Display the board */
4512     if (!pausing && !appData.noGUI) {
4513
4514       if (appData.premove)
4515           if (!gotPremove ||
4516              ((gameMode == IcsPlayingWhite) && (WhiteOnMove(currentMove))) ||
4517              ((gameMode == IcsPlayingBlack) && (!WhiteOnMove(currentMove))))
4518               ClearPremoveHighlights();
4519
4520       j = seekGraphUp; seekGraphUp = FALSE; // [HGM] seekgraph: when we draw a board, it overwrites the seek graph
4521         if(partnerUp) { flipView = originalFlip; partnerUp = FALSE; j = TRUE; } // [HGM] bughouse: restore view
4522       DrawPosition(j, boards[currentMove]);
4523
4524       DisplayMove(moveNum - 1);
4525       if (appData.ringBellAfterMoves && /*!ics_user_moved*/ // [HGM] use absolute method to recognize own move
4526             !((gameMode == IcsPlayingWhite) && (!WhiteOnMove(moveNum)) ||
4527               (gameMode == IcsPlayingBlack) &&  (WhiteOnMove(moveNum))   ) ) {
4528         if(newMove) RingBell(); else PlayIcsUnfinishedSound();
4529       }
4530     }
4531
4532     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
4533 #if ZIPPY
4534     if(bookHit) { // [HGM] book: simulate book reply
4535         static char bookMove[MSG_SIZ]; // a bit generous?
4536
4537         programStats.nodes = programStats.depth = programStats.time =
4538         programStats.score = programStats.got_only_move = 0;
4539         sprintf(programStats.movelist, "%s (xbook)", bookHit);
4540
4541         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
4542         strcat(bookMove, bookHit);
4543         HandleMachineMove(bookMove, &first);
4544     }
4545 #endif
4546 }
4547
4548 void
4549 GetMoveListEvent()
4550 {
4551     char buf[MSG_SIZ];
4552     if (appData.icsActive && gameMode != IcsIdle && ics_gamenum > 0) {
4553         ics_getting_history = H_REQUESTED;
4554         snprintf(buf, MSG_SIZ, "%smoves %d\n", ics_prefix, ics_gamenum);
4555         SendToICS(buf);
4556     }
4557 }
4558
4559 void
4560 AnalysisPeriodicEvent(force)
4561      int force;
4562 {
4563     if (((programStats.ok_to_send == 0 || programStats.line_is_book)
4564          && !force) || !appData.periodicUpdates)
4565       return;
4566
4567     /* Send . command to Crafty to collect stats */
4568     SendToProgram(".\n", &first);
4569
4570     /* Don't send another until we get a response (this makes
4571        us stop sending to old Crafty's which don't understand
4572        the "." command (sending illegal cmds resets node count & time,
4573        which looks bad)) */
4574     programStats.ok_to_send = 0;
4575 }
4576
4577 void ics_update_width(new_width)
4578         int new_width;
4579 {
4580         ics_printf("set width %d\n", new_width);
4581 }
4582
4583 void
4584 SendMoveToProgram(moveNum, cps)
4585      int moveNum;
4586      ChessProgramState *cps;
4587 {
4588     char buf[MSG_SIZ];
4589
4590     if (cps->useUsermove) {
4591       SendToProgram("usermove ", cps);
4592     }
4593     if (cps->useSAN) {
4594       char *space;
4595       if ((space = strchr(parseList[moveNum], ' ')) != NULL) {
4596         int len = space - parseList[moveNum];
4597         memcpy(buf, parseList[moveNum], len);
4598         buf[len++] = '\n';
4599         buf[len] = NULLCHAR;
4600       } else {
4601         snprintf(buf, MSG_SIZ,"%s\n", parseList[moveNum]);
4602       }
4603       SendToProgram(buf, cps);
4604     } else {
4605       if(cps->alphaRank) { /* [HGM] shogi: temporarily convert to shogi coordinates before sending */
4606         AlphaRank(moveList[moveNum], 4);
4607         SendToProgram(moveList[moveNum], cps);
4608         AlphaRank(moveList[moveNum], 4); // and back
4609       } else
4610       /* Added by Tord: Send castle moves in "O-O" in FRC games if required by
4611        * the engine. It would be nice to have a better way to identify castle
4612        * moves here. */
4613       if((gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom)
4614                                                                          && cps->useOOCastle) {
4615         int fromX = moveList[moveNum][0] - AAA;
4616         int fromY = moveList[moveNum][1] - ONE;
4617         int toX = moveList[moveNum][2] - AAA;
4618         int toY = moveList[moveNum][3] - ONE;
4619         if((boards[moveNum][fromY][fromX] == WhiteKing
4620             && boards[moveNum][toY][toX] == WhiteRook)
4621            || (boards[moveNum][fromY][fromX] == BlackKing
4622                && boards[moveNum][toY][toX] == BlackRook)) {
4623           if(toX > fromX) SendToProgram("O-O\n", cps);
4624           else SendToProgram("O-O-O\n", cps);
4625         }
4626         else SendToProgram(moveList[moveNum], cps);
4627       }
4628       else SendToProgram(moveList[moveNum], cps);
4629       /* End of additions by Tord */
4630     }
4631
4632     /* [HGM] setting up the opening has brought engine in force mode! */
4633     /*       Send 'go' if we are in a mode where machine should play. */
4634     if( (moveNum == 0 && setboardSpoiledMachineBlack && cps == &first) &&
4635         (gameMode == TwoMachinesPlay   ||
4636 #if ZIPPY
4637          gameMode == IcsPlayingBlack     || gameMode == IcsPlayingWhite ||
4638 #endif
4639          gameMode == MachinePlaysBlack || gameMode == MachinePlaysWhite) ) {
4640         SendToProgram("go\n", cps);
4641   if (appData.debugMode) {
4642     fprintf(debugFP, "(extra)\n");
4643   }
4644     }
4645     setboardSpoiledMachineBlack = 0;
4646 }
4647
4648 void
4649 SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar)
4650      ChessMove moveType;
4651      int fromX, fromY, toX, toY;
4652      char promoChar;
4653 {
4654     char user_move[MSG_SIZ];
4655
4656     switch (moveType) {
4657       default:
4658         snprintf(user_move, MSG_SIZ, _("say Internal error; bad moveType %d (%d,%d-%d,%d)"),
4659                 (int)moveType, fromX, fromY, toX, toY);
4660         DisplayError(user_move + strlen("say "), 0);
4661         break;
4662       case WhiteKingSideCastle:
4663       case BlackKingSideCastle:
4664       case WhiteQueenSideCastleWild:
4665       case BlackQueenSideCastleWild:
4666       /* PUSH Fabien */
4667       case WhiteHSideCastleFR:
4668       case BlackHSideCastleFR:
4669       /* POP Fabien */
4670         snprintf(user_move, MSG_SIZ, "o-o\n");
4671         break;
4672       case WhiteQueenSideCastle:
4673       case BlackQueenSideCastle:
4674       case WhiteKingSideCastleWild:
4675       case BlackKingSideCastleWild:
4676       /* PUSH Fabien */
4677       case WhiteASideCastleFR:
4678       case BlackASideCastleFR:
4679       /* POP Fabien */
4680         snprintf(user_move, MSG_SIZ, "o-o-o\n");
4681         break;
4682       case WhiteNonPromotion:
4683       case BlackNonPromotion:
4684         sprintf(user_move, "%c%c%c%c==\n", AAA + fromX, ONE + fromY, AAA + toX, ONE + toY);
4685         break;
4686       case WhitePromotion:
4687       case BlackPromotion:
4688         if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier || gameInfo.variant == VariantMakruk)
4689           snprintf(user_move, MSG_SIZ, "%c%c%c%c=%c\n",
4690                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4691                 PieceToChar(WhiteFerz));
4692         else if(gameInfo.variant == VariantGreat)
4693           snprintf(user_move, MSG_SIZ,"%c%c%c%c=%c\n",
4694                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4695                 PieceToChar(WhiteMan));
4696         else
4697           snprintf(user_move, MSG_SIZ, "%c%c%c%c=%c\n",
4698                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4699                 promoChar);
4700         break;
4701       case WhiteDrop:
4702       case BlackDrop:
4703       drop:
4704         snprintf(user_move, MSG_SIZ, "%c@%c%c\n",
4705                  ToUpper(PieceToChar((ChessSquare) fromX)),
4706                  AAA + toX, ONE + toY);
4707         break;
4708       case IllegalMove:  /* could be a variant we don't quite understand */
4709         if(fromY == DROP_RANK) goto drop; // We need 'IllegalDrop' move type?
4710       case NormalMove:
4711       case WhiteCapturesEnPassant:
4712       case BlackCapturesEnPassant:
4713         snprintf(user_move, MSG_SIZ,"%c%c%c%c\n",
4714                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY);
4715         break;
4716     }
4717     SendToICS(user_move);
4718     if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
4719         ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
4720 }
4721
4722 void
4723 UploadGameEvent()
4724 {   // [HGM] upload: send entire stored game to ICS as long-algebraic moves.
4725     int i, last = forwardMostMove; // make sure ICS reply cannot pre-empt us by clearing fmm
4726     static char *castlingStrings[4] = { "none", "kside", "qside", "both" };
4727     if(gameMode == IcsObserving || gameMode == IcsPlayingBlack || gameMode == IcsPlayingWhite) {
4728         DisplayError("You cannot do this while you are playing or observing", 0);
4729         return;
4730     }
4731     if(gameMode != IcsExamining) { // is this ever not the case?
4732         char buf[MSG_SIZ], *p, *fen, command[MSG_SIZ], bsetup = 0;
4733
4734         if(ics_type == ICS_ICC) { // on ICC match ourselves in applicable variant
4735           snprintf(command,MSG_SIZ, "match %s", ics_handle);
4736         } else { // on FICS we must first go to general examine mode
4737           safeStrCpy(command, "examine\nbsetup", sizeof(command)/sizeof(command[0])); // and specify variant within it with bsetups
4738         }
4739         if(gameInfo.variant != VariantNormal) {
4740             // try figure out wild number, as xboard names are not always valid on ICS
4741             for(i=1; i<=36; i++) {
4742               snprintf(buf, MSG_SIZ, "wild/%d", i);
4743                 if(StringToVariant(buf) == gameInfo.variant) break;
4744             }
4745             if(i<=36 && ics_type == ICS_ICC) snprintf(buf, MSG_SIZ,"%s w%d\n", command, i);
4746             else if(i == 22) snprintf(buf,MSG_SIZ, "%s fr\n", command);
4747             else snprintf(buf, MSG_SIZ,"%s %s\n", command, VariantName(gameInfo.variant));
4748         } else snprintf(buf, MSG_SIZ,"%s\n", ics_type == ICS_ICC ? command : "examine\n"); // match yourself or examine
4749         SendToICS(ics_prefix);
4750         SendToICS(buf);
4751         if(startedFromSetupPosition || backwardMostMove != 0) {
4752           fen = PositionToFEN(backwardMostMove, NULL);
4753           if(ics_type == ICS_ICC) { // on ICC we can simply send a complete FEN to set everything
4754             snprintf(buf, MSG_SIZ,"loadfen %s\n", fen);
4755             SendToICS(buf);
4756           } else { // FICS: everything has to set by separate bsetup commands
4757             p = strchr(fen, ' '); p[0] = NULLCHAR; // cut after board
4758             snprintf(buf, MSG_SIZ,"bsetup fen %s\n", fen);
4759             SendToICS(buf);
4760             if(!WhiteOnMove(backwardMostMove)) {
4761                 SendToICS("bsetup tomove black\n");
4762             }
4763             i = (strchr(p+3, 'K') != NULL) + 2*(strchr(p+3, 'Q') != NULL);
4764             snprintf(buf, MSG_SIZ,"bsetup wcastle %s\n", castlingStrings[i]);
4765             SendToICS(buf);
4766             i = (strchr(p+3, 'k') != NULL) + 2*(strchr(p+3, 'q') != NULL);
4767             snprintf(buf, MSG_SIZ, "bsetup bcastle %s\n", castlingStrings[i]);
4768             SendToICS(buf);
4769             i = boards[backwardMostMove][EP_STATUS];
4770             if(i >= 0) { // set e.p.
4771               snprintf(buf, MSG_SIZ,"bsetup eppos %c\n", i+AAA);
4772                 SendToICS(buf);
4773             }
4774             bsetup++;
4775           }
4776         }
4777       if(bsetup || ics_type != ICS_ICC && gameInfo.variant != VariantNormal)
4778             SendToICS("bsetup done\n"); // switch to normal examining.
4779     }
4780     for(i = backwardMostMove; i<last; i++) {
4781         char buf[20];
4782         snprintf(buf, sizeof(buf)/sizeof(buf[0]),"%s\n", parseList[i]);
4783         SendToICS(buf);
4784     }
4785     SendToICS(ics_prefix);
4786     SendToICS(ics_type == ICS_ICC ? "tag result Game in progress\n" : "commit\n");
4787 }
4788
4789 void
4790 CoordsToComputerAlgebraic(rf, ff, rt, ft, promoChar, move)
4791      int rf, ff, rt, ft;
4792      char promoChar;
4793      char move[7];
4794 {
4795     if (rf == DROP_RANK) {
4796       sprintf(move, "%c@%c%c\n",
4797                 ToUpper(PieceToChar((ChessSquare) ff)), AAA + ft, ONE + rt);
4798     } else {
4799         if (promoChar == 'x' || promoChar == NULLCHAR) {
4800           sprintf(move, "%c%c%c%c\n",
4801                     AAA + ff, ONE + rf, AAA + ft, ONE + rt);
4802         } else {
4803             sprintf(move, "%c%c%c%c%c\n",
4804                     AAA + ff, ONE + rf, AAA + ft, ONE + rt, promoChar);
4805         }
4806     }
4807 }
4808
4809 void
4810 ProcessICSInitScript(f)
4811      FILE *f;
4812 {
4813     char buf[MSG_SIZ];
4814
4815     while (fgets(buf, MSG_SIZ, f)) {
4816         SendToICSDelayed(buf,(long)appData.msLoginDelay);
4817     }
4818
4819     fclose(f);
4820 }
4821
4822
4823 /* [HGM] Shogi move preprocessor: swap digits for letters, vice versa */
4824 void
4825 AlphaRank(char *move, int n)
4826 {
4827 //    char *p = move, c; int x, y;
4828
4829     if (appData.debugMode) {
4830         fprintf(debugFP, "alphaRank(%s,%d)\n", move, n);
4831     }
4832
4833     if(move[1]=='*' &&
4834        move[2]>='0' && move[2]<='9' &&
4835        move[3]>='a' && move[3]<='x'    ) {
4836         move[1] = '@';
4837         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
4838         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
4839     } else
4840     if(move[0]>='0' && move[0]<='9' &&
4841        move[1]>='a' && move[1]<='x' &&
4842        move[2]>='0' && move[2]<='9' &&
4843        move[3]>='a' && move[3]<='x'    ) {
4844         /* input move, Shogi -> normal */
4845         move[0] = BOARD_RGHT  -1 - (move[0]-'1') + AAA;
4846         move[1] = BOARD_HEIGHT-1 - (move[1]-'a') + ONE;
4847         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
4848         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
4849     } else
4850     if(move[1]=='@' &&
4851        move[3]>='0' && move[3]<='9' &&
4852        move[2]>='a' && move[2]<='x'    ) {
4853         move[1] = '*';
4854         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
4855         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
4856     } else
4857     if(
4858        move[0]>='a' && move[0]<='x' &&
4859        move[3]>='0' && move[3]<='9' &&
4860        move[2]>='a' && move[2]<='x'    ) {
4861          /* output move, normal -> Shogi */
4862         move[0] = BOARD_RGHT - 1 - (move[0]-AAA) + '1';
4863         move[1] = BOARD_HEIGHT-1 - (move[1]-ONE) + 'a';
4864         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
4865         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
4866         if(move[4] == PieceToChar(BlackQueen)) move[4] = '+';
4867     }
4868     if (appData.debugMode) {
4869         fprintf(debugFP, "   out = '%s'\n", move);
4870     }
4871 }
4872
4873 char yy_textstr[8000];
4874
4875 /* Parser for moves from gnuchess, ICS, or user typein box */
4876 Boolean
4877 ParseOneMove(move, moveNum, moveType, fromX, fromY, toX, toY, promoChar)
4878      char *move;
4879      int moveNum;
4880      ChessMove *moveType;
4881      int *fromX, *fromY, *toX, *toY;
4882      char *promoChar;
4883 {
4884     *moveType = yylexstr(moveNum, move, yy_textstr, sizeof yy_textstr);
4885
4886     switch (*moveType) {
4887       case WhitePromotion:
4888       case BlackPromotion:
4889       case WhiteNonPromotion:
4890       case BlackNonPromotion:
4891       case NormalMove:
4892       case WhiteCapturesEnPassant:
4893       case BlackCapturesEnPassant:
4894       case WhiteKingSideCastle:
4895       case WhiteQueenSideCastle:
4896       case BlackKingSideCastle:
4897       case BlackQueenSideCastle:
4898       case WhiteKingSideCastleWild:
4899       case WhiteQueenSideCastleWild:
4900       case BlackKingSideCastleWild:
4901       case BlackQueenSideCastleWild:
4902       /* Code added by Tord: */
4903       case WhiteHSideCastleFR:
4904       case WhiteASideCastleFR:
4905       case BlackHSideCastleFR:
4906       case BlackASideCastleFR:
4907       /* End of code added by Tord */
4908       case IllegalMove:         /* bug or odd chess variant */
4909         *fromX = currentMoveString[0] - AAA;
4910         *fromY = currentMoveString[1] - ONE;
4911         *toX = currentMoveString[2] - AAA;
4912         *toY = currentMoveString[3] - ONE;
4913         *promoChar = currentMoveString[4];
4914         if (*fromX < BOARD_LEFT || *fromX >= BOARD_RGHT || *fromY < 0 || *fromY >= BOARD_HEIGHT ||
4915             *toX < BOARD_LEFT || *toX >= BOARD_RGHT || *toY < 0 || *toY >= BOARD_HEIGHT) {
4916     if (appData.debugMode) {
4917         fprintf(debugFP, "Off-board move (%d,%d)-(%d,%d)%c, type = %d\n", *fromX, *fromY, *toX, *toY, *promoChar, *moveType);
4918     }
4919             *fromX = *fromY = *toX = *toY = 0;
4920             return FALSE;
4921         }
4922         if (appData.testLegality) {
4923           return (*moveType != IllegalMove);
4924         } else {
4925           return !(*fromX == *toX && *fromY == *toY) && boards[moveNum][*fromY][*fromX] != EmptySquare &&
4926                         WhiteOnMove(moveNum) == (boards[moveNum][*fromY][*fromX] < BlackPawn);
4927         }
4928
4929       case WhiteDrop:
4930       case BlackDrop:
4931         *fromX = *moveType == WhiteDrop ?
4932           (int) CharToPiece(ToUpper(currentMoveString[0])) :
4933           (int) CharToPiece(ToLower(currentMoveString[0]));
4934         *fromY = DROP_RANK;
4935         *toX = currentMoveString[2] - AAA;
4936         *toY = currentMoveString[3] - ONE;
4937         *promoChar = NULLCHAR;
4938         return TRUE;
4939
4940       case AmbiguousMove:
4941       case ImpossibleMove:
4942       case EndOfFile:
4943       case ElapsedTime:
4944       case Comment:
4945       case PGNTag:
4946       case NAG:
4947       case WhiteWins:
4948       case BlackWins:
4949       case GameIsDrawn:
4950       default:
4951     if (appData.debugMode) {
4952         fprintf(debugFP, "Impossible move %s, type = %d\n", currentMoveString, *moveType);
4953     }
4954         /* bug? */
4955         *fromX = *fromY = *toX = *toY = 0;
4956         *promoChar = NULLCHAR;
4957         return FALSE;
4958     }
4959 }
4960
4961
4962 void
4963 ParsePV(char *pv, Boolean storeComments)
4964 { // Parse a string of PV moves, and append to current game, behind forwardMostMove
4965   int fromX, fromY, toX, toY; char promoChar;
4966   ChessMove moveType;
4967   Boolean valid;
4968   int nr = 0;
4969
4970   endPV = forwardMostMove;
4971   do {
4972     while(*pv == ' ' || *pv == '\n' || *pv == '\t') pv++; // must still read away whitespace
4973     if(nr == 0 && !storeComments && *pv == '(') pv++; // first (ponder) move can be in parentheses
4974     valid = ParseOneMove(pv, endPV, &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
4975 if(appData.debugMode){
4976 fprintf(debugFP,"parsePV: %d %c%c%c%c yy='%s'\nPV = '%s'\n", valid, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, yy_textstr, pv);
4977 }
4978     if(!valid && nr == 0 &&
4979        ParseOneMove(pv, endPV-1, &moveType, &fromX, &fromY, &toX, &toY, &promoChar)){
4980         nr++; moveType = Comment; // First move has been played; kludge to make sure we continue
4981         // Hande case where played move is different from leading PV move
4982         CopyBoard(boards[endPV+1], boards[endPV-1]); // tentatively unplay last game move
4983         CopyBoard(boards[endPV+2], boards[endPV-1]); // and play first move of PV
4984         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[endPV+2]);
4985         if(!CompareBoards(boards[endPV], boards[endPV+2])) {
4986           endPV += 2; // if position different, keep this
4987           moveList[endPV-1][0] = fromX + AAA;
4988           moveList[endPV-1][1] = fromY + ONE;
4989           moveList[endPV-1][2] = toX + AAA;
4990           moveList[endPV-1][3] = toY + ONE;
4991           parseList[endPV-1][0] = NULLCHAR;
4992           safeStrCpy(moveList[endPV-2], "_0_0", sizeof(moveList[endPV-2])/sizeof(moveList[endPV-2][0])); // suppress premove highlight on takeback move
4993         }
4994       }
4995     pv = strstr(pv, yy_textstr) + strlen(yy_textstr); // skip what we parsed
4996     if(nr == 0 && !storeComments && *pv == ')') pv++; // closing parenthesis of ponder move;
4997     if(moveType == Comment && storeComments) AppendComment(endPV, yy_textstr, FALSE);
4998     if(moveType == Comment || moveType == NAG || moveType == ElapsedTime) {
4999         valid++; // allow comments in PV
5000         continue;
5001     }
5002     nr++;
5003     if(endPV+1 > framePtr) break; // no space, truncate
5004     if(!valid) break;
5005     endPV++;
5006     CopyBoard(boards[endPV], boards[endPV-1]);
5007     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[endPV]);
5008     moveList[endPV-1][0] = fromX + AAA;
5009     moveList[endPV-1][1] = fromY + ONE;
5010     moveList[endPV-1][2] = toX + AAA;
5011     moveList[endPV-1][3] = toY + ONE;
5012     if(storeComments)
5013         CoordsToAlgebraic(boards[endPV - 1],
5014                              PosFlags(endPV - 1),
5015                              fromY, fromX, toY, toX, promoChar,
5016                              parseList[endPV - 1]);
5017     else
5018         parseList[endPV-1][0] = NULLCHAR;
5019   } while(valid);
5020   currentMove = endPV;
5021   if(currentMove == forwardMostMove) ClearPremoveHighlights(); else
5022   SetPremoveHighlights(moveList[currentMove-1][0]-AAA, moveList[currentMove-1][1]-ONE,
5023                        moveList[currentMove-1][2]-AAA, moveList[currentMove-1][3]-ONE);
5024   DrawPosition(TRUE, boards[currentMove]);
5025 }
5026
5027 static int lastX, lastY;
5028
5029 Boolean
5030 LoadMultiPV(int x, int y, char *buf, int index, int *start, int *end)
5031 {
5032         int startPV;
5033         char *p;
5034
5035         if(index < 0 || index >= strlen(buf)) return FALSE; // sanity
5036         lastX = x; lastY = y;
5037         while(index > 0 && buf[index-1] != '\n') index--; // beginning of line
5038         startPV = index;
5039         while(buf[index] != '\n') if(buf[index++] == '\t') startPV = index;
5040         if(index == startPV && (p = StrCaseStr(buf+index, "PV="))) startPV = p - buf + 3;
5041         index = startPV;
5042         do{ while(buf[index] && buf[index] != '\n') index++;
5043         } while(buf[index] == '\n' && buf[index+1] == '\\' && buf[index+2] == ' ' && index++); // join kibitzed PV continuation line
5044         buf[index] = 0;
5045         ParsePV(buf+startPV, FALSE);
5046         *start = startPV; *end = index-1;
5047         return TRUE;
5048 }
5049
5050 Boolean
5051 LoadPV(int x, int y)
5052 { // called on right mouse click to load PV
5053   int which = gameMode == TwoMachinesPlay && (WhiteOnMove(forwardMostMove) == (second.twoMachinesColor[0] == 'w'));
5054   lastX = x; lastY = y;
5055   ParsePV(lastPV[which], FALSE); // load the PV of the thinking engine in the boards array.
5056   return TRUE;
5057 }
5058
5059 void
5060 UnLoadPV()
5061 {
5062   if(endPV < 0) return;
5063   endPV = -1;
5064   currentMove = forwardMostMove;
5065   ClearPremoveHighlights();
5066   DrawPosition(TRUE, boards[currentMove]);
5067 }
5068
5069 void
5070 MovePV(int x, int y, int h)
5071 { // step through PV based on mouse coordinates (called on mouse move)
5072   int margin = h>>3, step = 0;
5073
5074   if(endPV < 0) return;
5075   // we must somehow check if right button is still down (might be released off board!)
5076   if(y < margin && (abs(x - lastX) > 6 || abs(y - lastY) > 6)) step = 1; else
5077   if(y > h - margin && (abs(x - lastX) > 6 || abs(y - lastY) > 6)) step = -1; else
5078   if( y > lastY + 6 ) step = -1; else if(y < lastY - 6) step = 1;
5079   if(!step) return;
5080   lastX = x; lastY = y;
5081   if(currentMove + step > endPV || currentMove + step < forwardMostMove) step = 0;
5082   currentMove += step;
5083   if(currentMove == forwardMostMove) ClearPremoveHighlights(); else
5084   SetPremoveHighlights(moveList[currentMove-1][0]-AAA, moveList[currentMove-1][1]-ONE,
5085                        moveList[currentMove-1][2]-AAA, moveList[currentMove-1][3]-ONE);
5086   DrawPosition(FALSE, boards[currentMove]);
5087 }
5088
5089
5090 // [HGM] shuffle: a general way to suffle opening setups, applicable to arbitrary variants.
5091 // All positions will have equal probability, but the current method will not provide a unique
5092 // numbering scheme for arrays that contain 3 or more pieces of the same kind.
5093 #define DARK 1
5094 #define LITE 2
5095 #define ANY 3
5096
5097 int squaresLeft[4];
5098 int piecesLeft[(int)BlackPawn];
5099 int seed, nrOfShuffles;
5100
5101 void GetPositionNumber()
5102 {       // sets global variable seed
5103         int i;
5104
5105         seed = appData.defaultFrcPosition;
5106         if(seed < 0) { // randomize based on time for negative FRC position numbers
5107                 for(i=0; i<50; i++) seed += random();
5108                 seed = random() ^ random() >> 8 ^ random() << 8;
5109                 if(seed<0) seed = -seed;
5110         }
5111 }
5112
5113 int put(Board board, int pieceType, int rank, int n, int shade)
5114 // put the piece on the (n-1)-th empty squares of the given shade
5115 {
5116         int i;
5117
5118         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
5119                 if( (((i-BOARD_LEFT)&1)+1) & shade && board[rank][i] == EmptySquare && n-- == 0) {
5120                         board[rank][i] = (ChessSquare) pieceType;
5121                         squaresLeft[((i-BOARD_LEFT)&1) + 1]--;
5122                         squaresLeft[ANY]--;
5123                         piecesLeft[pieceType]--;
5124                         return i;
5125                 }
5126         }
5127         return -1;
5128 }
5129
5130
5131 void AddOnePiece(Board board, int pieceType, int rank, int shade)
5132 // calculate where the next piece goes, (any empty square), and put it there
5133 {
5134         int i;
5135
5136         i = seed % squaresLeft[shade];
5137         nrOfShuffles *= squaresLeft[shade];
5138         seed /= squaresLeft[shade];
5139         put(board, pieceType, rank, i, shade);
5140 }
5141
5142 void AddTwoPieces(Board board, int pieceType, int rank)
5143 // calculate where the next 2 identical pieces go, (any empty square), and put it there
5144 {
5145         int i, n=squaresLeft[ANY], j=n-1, k;
5146
5147         k = n*(n-1)/2; // nr of possibilities, not counting permutations
5148         i = seed % k;  // pick one
5149         nrOfShuffles *= k;
5150         seed /= k;
5151         while(i >= j) i -= j--;
5152         j = n - 1 - j; i += j;
5153         put(board, pieceType, rank, j, ANY);
5154         put(board, pieceType, rank, i, ANY);
5155 }
5156
5157 void SetUpShuffle(Board board, int number)
5158 {
5159         int i, p, first=1;
5160
5161         GetPositionNumber(); nrOfShuffles = 1;
5162
5163         squaresLeft[DARK] = (BOARD_RGHT - BOARD_LEFT + 1)/2;
5164         squaresLeft[ANY]  = BOARD_RGHT - BOARD_LEFT;
5165         squaresLeft[LITE] = squaresLeft[ANY] - squaresLeft[DARK];
5166
5167         for(p = 0; p<=(int)WhiteKing; p++) piecesLeft[p] = 0;
5168
5169         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // count pieces and clear board
5170             p = (int) board[0][i];
5171             if(p < (int) BlackPawn) piecesLeft[p] ++;
5172             board[0][i] = EmptySquare;
5173         }
5174
5175         if(PosFlags(0) & F_ALL_CASTLE_OK) {
5176             // shuffles restricted to allow normal castling put KRR first
5177             if(piecesLeft[(int)WhiteKing]) // King goes rightish of middle
5178                 put(board, WhiteKing, 0, (gameInfo.boardWidth+1)/2, ANY);
5179             else if(piecesLeft[(int)WhiteUnicorn]) // in Knightmate Unicorn castles
5180                 put(board, WhiteUnicorn, 0, (gameInfo.boardWidth+1)/2, ANY);
5181             if(piecesLeft[(int)WhiteRook]) // First supply a Rook for K-side castling
5182                 put(board, WhiteRook, 0, gameInfo.boardWidth-2, ANY);
5183             if(piecesLeft[(int)WhiteRook]) // Then supply a Rook for Q-side castling
5184                 put(board, WhiteRook, 0, 0, ANY);
5185             // in variants with super-numerary Kings and Rooks, we leave these for the shuffle
5186         }
5187
5188         if(((BOARD_RGHT-BOARD_LEFT) & 1) == 0)
5189             // only for even boards make effort to put pairs of colorbound pieces on opposite colors
5190             for(p = (int) WhiteKing; p > (int) WhitePawn; p--) {
5191                 if(p != (int) WhiteBishop && p != (int) WhiteFerz && p != (int) WhiteAlfil) continue;
5192                 while(piecesLeft[p] >= 2) {
5193                     AddOnePiece(board, p, 0, LITE);
5194                     AddOnePiece(board, p, 0, DARK);
5195                 }
5196                 // Odd color-bound pieces are shuffled with the rest (to not run out of paired squares)
5197             }
5198
5199         for(p = (int) WhiteKing - 2; p > (int) WhitePawn; p--) {
5200             // Remaining pieces (non-colorbound, or odd color bound) can be put anywhere
5201             // but we leave King and Rooks for last, to possibly obey FRC restriction
5202             if(p == (int)WhiteRook) continue;
5203             while(piecesLeft[p] >= 2) AddTwoPieces(board, p, 0); // add in pairs, for not counting permutations
5204             if(piecesLeft[p]) AddOnePiece(board, p, 0, ANY);     // add the odd piece
5205         }
5206
5207         // now everything is placed, except perhaps King (Unicorn) and Rooks
5208
5209         if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
5210             // Last King gets castling rights
5211             while(piecesLeft[(int)WhiteUnicorn]) {
5212                 i = put(board, WhiteUnicorn, 0, piecesLeft[(int)WhiteRook]/2, ANY);
5213                 initialRights[2]  = initialRights[5]  = board[CASTLING][2] = board[CASTLING][5] = i;
5214             }
5215
5216             while(piecesLeft[(int)WhiteKing]) {
5217                 i = put(board, WhiteKing, 0, piecesLeft[(int)WhiteRook]/2, ANY);
5218                 initialRights[2]  = initialRights[5]  = board[CASTLING][2] = board[CASTLING][5] = i;
5219             }
5220
5221
5222         } else {
5223             while(piecesLeft[(int)WhiteKing])    AddOnePiece(board, WhiteKing, 0, ANY);
5224             while(piecesLeft[(int)WhiteUnicorn]) AddOnePiece(board, WhiteUnicorn, 0, ANY);
5225         }
5226
5227         // Only Rooks can be left; simply place them all
5228         while(piecesLeft[(int)WhiteRook]) {
5229                 i = put(board, WhiteRook, 0, 0, ANY);
5230                 if(PosFlags(0) & F_FRC_TYPE_CASTLING) { // first and last Rook get FRC castling rights
5231                         if(first) {
5232                                 first=0;
5233                                 initialRights[1]  = initialRights[4]  = board[CASTLING][1] = board[CASTLING][4] = i;
5234                         }
5235                         initialRights[0]  = initialRights[3]  = board[CASTLING][0] = board[CASTLING][3] = i;
5236                 }
5237         }
5238         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // copy black from white
5239             board[BOARD_HEIGHT-1][i] =  (int) board[0][i] < BlackPawn ? WHITE_TO_BLACK board[0][i] : EmptySquare;
5240         }
5241
5242         if(number >= 0) appData.defaultFrcPosition %= nrOfShuffles; // normalize
5243 }
5244
5245 int SetCharTable( char *table, const char * map )
5246 /* [HGM] moved here from winboard.c because of its general usefulness */
5247 /*       Basically a safe strcpy that uses the last character as King */
5248 {
5249     int result = FALSE; int NrPieces;
5250
5251     if( map != NULL && (NrPieces=strlen(map)) <= (int) EmptySquare
5252                     && NrPieces >= 12 && !(NrPieces&1)) {
5253         int i; /* [HGM] Accept even length from 12 to 34 */
5254
5255         for( i=0; i<(int) EmptySquare; i++ ) table[i] = '.';
5256         for( i=0; i<NrPieces/2-1; i++ ) {
5257             table[i] = map[i];
5258             table[i + (int)BlackPawn - (int) WhitePawn] = map[i+NrPieces/2];
5259         }
5260         table[(int) WhiteKing]  = map[NrPieces/2-1];
5261         table[(int) BlackKing]  = map[NrPieces-1];
5262
5263         result = TRUE;
5264     }
5265
5266     return result;
5267 }
5268
5269 void Prelude(Board board)
5270 {       // [HGM] superchess: random selection of exo-pieces
5271         int i, j, k; ChessSquare p;
5272         static ChessSquare exoPieces[4] = { WhiteAngel, WhiteMarshall, WhiteSilver, WhiteLance };
5273
5274         GetPositionNumber(); // use FRC position number
5275
5276         if(appData.pieceToCharTable != NULL) { // select pieces to participate from given char table
5277             SetCharTable(pieceToChar, appData.pieceToCharTable);
5278             for(i=(int)WhiteQueen+1, j=0; i<(int)WhiteKing && j<4; i++)
5279                 if(PieceToChar((ChessSquare)i) != '.') exoPieces[j++] = (ChessSquare) i;
5280         }
5281
5282         j = seed%4;                 seed /= 4;
5283         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
5284         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
5285         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
5286         j = seed%3 + (seed%3 >= j); seed /= 3;
5287         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
5288         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
5289         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
5290         j = seed%3;                 seed /= 3;
5291         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
5292         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
5293         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
5294         j = seed%2 + (seed%2 >= j); seed /= 2;
5295         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
5296         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
5297         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
5298         j = seed%4; seed /= 4; put(board, exoPieces[3],    0, j, ANY);
5299         j = seed%3; seed /= 3; put(board, exoPieces[2],   0, j, ANY);
5300         j = seed%2; seed /= 2; put(board, exoPieces[1], 0, j, ANY);
5301         put(board, exoPieces[0],    0, 0, ANY);
5302         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) board[BOARD_HEIGHT-1][i] = WHITE_TO_BLACK board[0][i];
5303 }
5304
5305 void
5306 InitPosition(redraw)
5307      int redraw;
5308 {
5309     ChessSquare (* pieces)[BOARD_FILES];
5310     int i, j, pawnRow, overrule,
5311     oldx = gameInfo.boardWidth,
5312     oldy = gameInfo.boardHeight,
5313     oldh = gameInfo.holdingsWidth,
5314     oldv = gameInfo.variant;
5315
5316     if(appData.icsActive) shuffleOpenings = FALSE; // [HGM] shuffle: in ICS mode, only shuffle on ICS request
5317
5318     /* [AS] Initialize pv info list [HGM] and game status */
5319     {
5320         for( i=0; i<=framePtr; i++ ) { // [HGM] vari: spare saved variations
5321             pvInfoList[i].depth = 0;
5322             boards[i][EP_STATUS] = EP_NONE;
5323             for( j=0; j<BOARD_FILES-2; j++ ) boards[i][CASTLING][j] = NoRights;
5324         }
5325
5326         initialRulePlies = 0; /* 50-move counter start */
5327
5328         castlingRank[0] = castlingRank[1] = castlingRank[2] = 0;
5329         castlingRank[3] = castlingRank[4] = castlingRank[5] = BOARD_HEIGHT-1;
5330     }
5331
5332
5333     /* [HGM] logic here is completely changed. In stead of full positions */
5334     /* the initialized data only consist of the two backranks. The switch */
5335     /* selects which one we will use, which is than copied to the Board   */
5336     /* initialPosition, which for the rest is initialized by Pawns and    */
5337     /* empty squares. This initial position is then copied to boards[0],  */
5338     /* possibly after shuffling, so that it remains available.            */
5339
5340     gameInfo.holdingsWidth = 0; /* default board sizes */
5341     gameInfo.boardWidth    = 8;
5342     gameInfo.boardHeight   = 8;
5343     gameInfo.holdingsSize  = 0;
5344     nrCastlingRights = -1; /* [HGM] Kludge to indicate default should be used */
5345     for(i=0; i<BOARD_FILES-2; i++)
5346       initialPosition[CASTLING][i] = initialRights[i] = NoRights; /* but no rights yet */
5347     initialPosition[EP_STATUS] = EP_NONE;
5348     SetCharTable(pieceToChar, "PNBRQ...........Kpnbrq...........k");
5349     if(startVariant == gameInfo.variant) // [HGM] nicks: enable nicknames in original variant
5350          SetCharTable(pieceNickName, appData.pieceNickNames);
5351     else SetCharTable(pieceNickName, "............");
5352     pieces = FIDEArray;
5353
5354     switch (gameInfo.variant) {
5355     case VariantFischeRandom:
5356       shuffleOpenings = TRUE;
5357     default:
5358       break;
5359     case VariantShatranj:
5360       pieces = ShatranjArray;
5361       nrCastlingRights = 0;
5362       SetCharTable(pieceToChar, "PN.R.QB...Kpn.r.qb...k");
5363       break;
5364     case VariantMakruk:
5365       pieces = makrukArray;
5366       nrCastlingRights = 0;
5367       startedFromSetupPosition = TRUE;
5368       SetCharTable(pieceToChar, "PN.R.M....SKpn.r.m....sk");
5369       break;
5370     case VariantTwoKings:
5371       pieces = twoKingsArray;
5372       break;
5373     case VariantCapaRandom:
5374       shuffleOpenings = TRUE;
5375     case VariantCapablanca:
5376       pieces = CapablancaArray;
5377       gameInfo.boardWidth = 10;
5378       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
5379       break;
5380     case VariantGothic:
5381       pieces = GothicArray;
5382       gameInfo.boardWidth = 10;
5383       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
5384       break;
5385     case VariantSChess:
5386       SetCharTable(pieceToChar, "PNBRQ..HEKpnbrq..hek");
5387       gameInfo.holdingsSize = 7;
5388       break;
5389     case VariantJanus:
5390       pieces = JanusArray;
5391       gameInfo.boardWidth = 10;
5392       SetCharTable(pieceToChar, "PNBRQ..JKpnbrq..jk");
5393       nrCastlingRights = 6;
5394         initialPosition[CASTLING][0] = initialRights[0] = BOARD_RGHT-1;
5395         initialPosition[CASTLING][1] = initialRights[1] = BOARD_LEFT;
5396         initialPosition[CASTLING][2] = initialRights[2] =(BOARD_WIDTH-1)>>1;
5397         initialPosition[CASTLING][3] = initialRights[3] = BOARD_RGHT-1;
5398         initialPosition[CASTLING][4] = initialRights[4] = BOARD_LEFT;
5399         initialPosition[CASTLING][5] = initialRights[5] =(BOARD_WIDTH-1)>>1;
5400       break;
5401     case VariantFalcon:
5402       pieces = FalconArray;
5403       gameInfo.boardWidth = 10;
5404       SetCharTable(pieceToChar, "PNBRQ.............FKpnbrq.............fk");
5405       break;
5406     case VariantXiangqi:
5407       pieces = XiangqiArray;
5408       gameInfo.boardWidth  = 9;
5409       gameInfo.boardHeight = 10;
5410       nrCastlingRights = 0;
5411       SetCharTable(pieceToChar, "PH.R.AE..K.C.ph.r.ae..k.c.");
5412       break;
5413     case VariantShogi:
5414       pieces = ShogiArray;
5415       gameInfo.boardWidth  = 9;
5416       gameInfo.boardHeight = 9;
5417       gameInfo.holdingsSize = 7;
5418       nrCastlingRights = 0;
5419       SetCharTable(pieceToChar, "PNBRLS...G.++++++Kpnbrls...g.++++++k");
5420       break;
5421     case VariantCourier:
5422       pieces = CourierArray;
5423       gameInfo.boardWidth  = 12;
5424       nrCastlingRights = 0;
5425       SetCharTable(pieceToChar, "PNBR.FE..WMKpnbr.fe..wmk");
5426       break;
5427     case VariantKnightmate:
5428       pieces = KnightmateArray;
5429       SetCharTable(pieceToChar, "P.BRQ.....M.........K.p.brq.....m.........k.");
5430       break;
5431     case VariantFairy:
5432       pieces = fairyArray;
5433       SetCharTable(pieceToChar, "PNBRQFEACWMOHIJGDVLSUKpnbrqfeacwmohijgdvlsuk");
5434       break;
5435     case VariantGreat:
5436       pieces = GreatArray;
5437       gameInfo.boardWidth = 10;
5438       SetCharTable(pieceToChar, "PN....E...S..HWGMKpn....e...s..hwgmk");
5439       gameInfo.holdingsSize = 8;
5440       break;
5441     case VariantSuper:
5442       pieces = FIDEArray;
5443       SetCharTable(pieceToChar, "PNBRQ..SE.......V.AKpnbrq..se.......v.ak");
5444       gameInfo.holdingsSize = 8;
5445       startedFromSetupPosition = TRUE;
5446       break;
5447     case VariantCrazyhouse:
5448     case VariantBughouse:
5449       pieces = FIDEArray;
5450       SetCharTable(pieceToChar, "PNBRQ.......~~~~Kpnbrq.......~~~~k");
5451       gameInfo.holdingsSize = 5;
5452       break;
5453     case VariantWildCastle:
5454       pieces = FIDEArray;
5455       /* !!?shuffle with kings guaranteed to be on d or e file */
5456       shuffleOpenings = 1;
5457       break;
5458     case VariantNoCastle:
5459       pieces = FIDEArray;
5460       nrCastlingRights = 0;
5461       /* !!?unconstrained back-rank shuffle */
5462       shuffleOpenings = 1;
5463       break;
5464     }
5465
5466     overrule = 0;
5467     if(appData.NrFiles >= 0) {
5468         if(gameInfo.boardWidth != appData.NrFiles) overrule++;
5469         gameInfo.boardWidth = appData.NrFiles;
5470     }
5471     if(appData.NrRanks >= 0) {
5472         gameInfo.boardHeight = appData.NrRanks;
5473     }
5474     if(appData.holdingsSize >= 0) {
5475         i = appData.holdingsSize;
5476         if(i > gameInfo.boardHeight) i = gameInfo.boardHeight;
5477         gameInfo.holdingsSize = i;
5478     }
5479     if(gameInfo.holdingsSize) gameInfo.holdingsWidth = 2;
5480     if(BOARD_HEIGHT > BOARD_RANKS || BOARD_WIDTH > BOARD_FILES)
5481         DisplayFatalError(_("Recompile to support this BOARD_RANKS or BOARD_FILES!"), 0, 2);
5482
5483     pawnRow = gameInfo.boardHeight - 7; /* seems to work in all common variants */
5484     if(pawnRow < 1) pawnRow = 1;
5485     if(gameInfo.variant == VariantMakruk) pawnRow = 2;
5486
5487     /* User pieceToChar list overrules defaults */
5488     if(appData.pieceToCharTable != NULL)
5489         SetCharTable(pieceToChar, appData.pieceToCharTable);
5490
5491     for( j=0; j<BOARD_WIDTH; j++ ) { ChessSquare s = EmptySquare;
5492
5493         if(j==BOARD_LEFT-1 || j==BOARD_RGHT)
5494             s = (ChessSquare) 0; /* account holding counts in guard band */
5495         for( i=0; i<BOARD_HEIGHT; i++ )
5496             initialPosition[i][j] = s;
5497
5498         if(j < BOARD_LEFT || j >= BOARD_RGHT || overrule) continue;
5499         initialPosition[0][j] = pieces[0][j-gameInfo.holdingsWidth];
5500         initialPosition[pawnRow][j] = WhitePawn;
5501         initialPosition[BOARD_HEIGHT-pawnRow-1][j] = BlackPawn;
5502         if(gameInfo.variant == VariantXiangqi) {
5503             if(j&1) {
5504                 initialPosition[pawnRow][j] =
5505                 initialPosition[BOARD_HEIGHT-pawnRow-1][j] = EmptySquare;
5506                 if(j==BOARD_LEFT+1 || j>=BOARD_RGHT-2) {
5507                    initialPosition[2][j] = WhiteCannon;
5508                    initialPosition[BOARD_HEIGHT-3][j] = BlackCannon;
5509                 }
5510             }
5511         }
5512         initialPosition[BOARD_HEIGHT-1][j] =  pieces[1][j-gameInfo.holdingsWidth];
5513     }
5514     if( (gameInfo.variant == VariantShogi) && !overrule ) {
5515
5516             j=BOARD_LEFT+1;
5517             initialPosition[1][j] = WhiteBishop;
5518             initialPosition[BOARD_HEIGHT-2][j] = BlackRook;
5519             j=BOARD_RGHT-2;
5520             initialPosition[1][j] = WhiteRook;
5521             initialPosition[BOARD_HEIGHT-2][j] = BlackBishop;
5522     }
5523
5524     if( nrCastlingRights == -1) {
5525         /* [HGM] Build normal castling rights (must be done after board sizing!) */
5526         /*       This sets default castling rights from none to normal corners   */
5527         /* Variants with other castling rights must set them themselves above    */
5528         nrCastlingRights = 6;
5529
5530         initialPosition[CASTLING][0] = initialRights[0] = BOARD_RGHT-1;
5531         initialPosition[CASTLING][1] = initialRights[1] = BOARD_LEFT;
5532         initialPosition[CASTLING][2] = initialRights[2] = BOARD_WIDTH>>1;
5533         initialPosition[CASTLING][3] = initialRights[3] = BOARD_RGHT-1;
5534         initialPosition[CASTLING][4] = initialRights[4] = BOARD_LEFT;
5535         initialPosition[CASTLING][5] = initialRights[5] = BOARD_WIDTH>>1;
5536      }
5537
5538      if(gameInfo.variant == VariantSuper) Prelude(initialPosition);
5539      if(gameInfo.variant == VariantGreat) { // promotion commoners
5540         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-1] = WhiteMan;
5541         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-2] = 9;
5542         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][0] = BlackMan;
5543         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][1] = 9;
5544      }
5545      if( gameInfo.variant == VariantSChess ) {
5546       initialPosition[1][0] = BlackMarshall;
5547       initialPosition[2][0] = BlackAngel;
5548       initialPosition[6][BOARD_WIDTH-1] = WhiteMarshall;
5549       initialPosition[5][BOARD_WIDTH-1] = WhiteAngel;
5550       initialPosition[1][1] = initialPosition[2][1] =
5551       initialPosition[6][BOARD_WIDTH-2] = initialPosition[5][BOARD_WIDTH-2] = 1;
5552      }
5553   if (appData.debugMode) {
5554     fprintf(debugFP, "shuffleOpenings = %d\n", shuffleOpenings);
5555   }
5556     if(shuffleOpenings) {
5557         SetUpShuffle(initialPosition, appData.defaultFrcPosition);
5558         startedFromSetupPosition = TRUE;
5559     }
5560     if(startedFromPositionFile) {
5561       /* [HGM] loadPos: use PositionFile for every new game */
5562       CopyBoard(initialPosition, filePosition);
5563       for(i=0; i<nrCastlingRights; i++)
5564           initialRights[i] = filePosition[CASTLING][i];
5565       startedFromSetupPosition = TRUE;
5566     }
5567
5568     CopyBoard(boards[0], initialPosition);
5569
5570     if(oldx != gameInfo.boardWidth ||
5571        oldy != gameInfo.boardHeight ||
5572        oldh != gameInfo.holdingsWidth
5573 #ifdef GOTHIC
5574        || oldv == VariantGothic ||        // For licensing popups
5575        gameInfo.variant == VariantGothic
5576 #endif
5577 #ifdef FALCON
5578        || oldv == VariantFalcon ||
5579        gameInfo.variant == VariantFalcon
5580 #endif
5581                                          )
5582             InitDrawingSizes(-2 ,0);
5583
5584     if (redraw)
5585       DrawPosition(TRUE, boards[currentMove]);
5586 }
5587
5588 void
5589 SendBoard(cps, moveNum)
5590      ChessProgramState *cps;
5591      int moveNum;
5592 {
5593     char message[MSG_SIZ];
5594
5595     if (cps->useSetboard) {
5596       char* fen = PositionToFEN(moveNum, cps->fenOverride);
5597       snprintf(message, MSG_SIZ,"setboard %s\n", fen);
5598       SendToProgram(message, cps);
5599       free(fen);
5600
5601     } else {
5602       ChessSquare *bp;
5603       int i, j;
5604       /* Kludge to set black to move, avoiding the troublesome and now
5605        * deprecated "black" command.
5606        */
5607       if (!WhiteOnMove(moveNum)) // [HGM] but better a deprecated command than an illegal move...
5608         SendToProgram(boards[0][1][BOARD_LEFT] == WhitePawn ? "a2a3\n" : "black\n", cps);
5609
5610       SendToProgram("edit\n", cps);
5611       SendToProgram("#\n", cps);
5612       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
5613         bp = &boards[moveNum][i][BOARD_LEFT];
5614         for (j = BOARD_LEFT; j < BOARD_RGHT; j++, bp++) {
5615           if ((int) *bp < (int) BlackPawn) {
5616             snprintf(message, MSG_SIZ, "%c%c%c\n", PieceToChar(*bp),
5617                     AAA + j, ONE + i);
5618             if(message[0] == '+' || message[0] == '~') {
5619               snprintf(message, MSG_SIZ,"%c%c%c+\n",
5620                         PieceToChar((ChessSquare)(DEMOTED *bp)),
5621                         AAA + j, ONE + i);
5622             }
5623             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
5624                 message[1] = BOARD_RGHT   - 1 - j + '1';
5625                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
5626             }
5627             SendToProgram(message, cps);
5628           }
5629         }
5630       }
5631
5632       SendToProgram("c\n", cps);
5633       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
5634         bp = &boards[moveNum][i][BOARD_LEFT];
5635         for (j = BOARD_LEFT; j < BOARD_RGHT; j++, bp++) {
5636           if (((int) *bp != (int) EmptySquare)
5637               && ((int) *bp >= (int) BlackPawn)) {
5638             snprintf(message,MSG_SIZ, "%c%c%c\n", ToUpper(PieceToChar(*bp)),
5639                     AAA + j, ONE + i);
5640             if(message[0] == '+' || message[0] == '~') {
5641               snprintf(message, MSG_SIZ,"%c%c%c+\n",
5642                         PieceToChar((ChessSquare)(DEMOTED *bp)),
5643                         AAA + j, ONE + i);
5644             }
5645             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
5646                 message[1] = BOARD_RGHT   - 1 - j + '1';
5647                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
5648             }
5649             SendToProgram(message, cps);
5650           }
5651         }
5652       }
5653
5654       SendToProgram(".\n", cps);
5655     }
5656     setboardSpoiledMachineBlack = 0; /* [HGM] assume WB 4.2.7 already solves this after sending setboard */
5657 }
5658
5659 static int autoQueen; // [HGM] oneclick
5660
5661 int
5662 HasPromotionChoice(int fromX, int fromY, int toX, int toY, char *promoChoice)
5663 {
5664     /* [HGM] rewritten IsPromotion to only flag promotions that offer a choice */
5665     /* [HGM] add Shogi promotions */
5666     int promotionZoneSize=1, highestPromotingPiece = (int)WhitePawn;
5667     ChessSquare piece;
5668     ChessMove moveType;
5669     Boolean premove;
5670
5671     if(fromX < BOARD_LEFT || fromX >= BOARD_RGHT) return FALSE; // drop
5672     if(toX   < BOARD_LEFT || toX   >= BOARD_RGHT) return FALSE; // move into holdings
5673
5674     if(gameMode == EditPosition || gameInfo.variant == VariantXiangqi || // no promotions
5675       !(fromX >=0 && fromY >= 0 && toX >= 0 && toY >= 0) ) // invalid move
5676         return FALSE;
5677
5678     piece = boards[currentMove][fromY][fromX];
5679     if(gameInfo.variant == VariantShogi) {
5680         promotionZoneSize = BOARD_HEIGHT/3;
5681         highestPromotingPiece = (int)WhiteFerz;
5682     } else if(gameInfo.variant == VariantMakruk) {
5683         promotionZoneSize = 3;
5684     }
5685
5686     // next weed out all moves that do not touch the promotion zone at all
5687     if((int)piece >= BlackPawn) {
5688         if(toY >= promotionZoneSize && fromY >= promotionZoneSize)
5689              return FALSE;
5690         highestPromotingPiece = WHITE_TO_BLACK highestPromotingPiece;
5691     } else {
5692         if(  toY < BOARD_HEIGHT - promotionZoneSize &&
5693            fromY < BOARD_HEIGHT - promotionZoneSize) return FALSE;
5694     }
5695
5696     if( (int)piece > highestPromotingPiece ) return FALSE; // non-promoting piece
5697
5698     // weed out mandatory Shogi promotions
5699     if(gameInfo.variant == VariantShogi) {
5700         if(piece >= BlackPawn) {
5701             if(toY == 0 && piece == BlackPawn ||
5702                toY == 0 && piece == BlackQueen ||
5703                toY <= 1 && piece == BlackKnight) {
5704                 *promoChoice = '+';
5705                 return FALSE;
5706             }
5707         } else {
5708             if(toY == BOARD_HEIGHT-1 && piece == WhitePawn ||
5709                toY == BOARD_HEIGHT-1 && piece == WhiteQueen ||
5710                toY >= BOARD_HEIGHT-2 && piece == WhiteKnight) {
5711                 *promoChoice = '+';
5712                 return FALSE;
5713             }
5714         }
5715     }
5716
5717     // weed out obviously illegal Pawn moves
5718     if(appData.testLegality  && (piece == WhitePawn || piece == BlackPawn) ) {
5719         if(toX > fromX+1 || toX < fromX-1) return FALSE; // wide
5720         if(piece == WhitePawn && toY != fromY+1) return FALSE; // deep
5721         if(piece == BlackPawn && toY != fromY-1) return FALSE; // deep
5722         if(fromX != toX && gameInfo.variant == VariantShogi) return FALSE;
5723         // note we are not allowed to test for valid (non-)capture, due to premove
5724     }
5725
5726     // we either have a choice what to promote to, or (in Shogi) whether to promote
5727     if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier || gameInfo.variant == VariantMakruk) {
5728         *promoChoice = PieceToChar(BlackFerz);  // no choice
5729         return FALSE;
5730     }
5731     // no sense asking what we must promote to if it is going to explode...
5732     if(gameInfo.variant == VariantAtomic && boards[currentMove][toY][toX] != EmptySquare) {
5733         *promoChoice = PieceToChar(BlackQueen); // Queen as good as any
5734         return FALSE;
5735     }
5736     if(autoQueen) { // predetermined
5737         if(gameInfo.variant == VariantSuicide || gameInfo.variant == VariantLosers)
5738              *promoChoice = PieceToChar(BlackKing); // in Suicide Q is the last thing we want
5739         else *promoChoice = PieceToChar(BlackQueen);
5740         return FALSE;
5741     }
5742
5743     // suppress promotion popup on illegal moves that are not premoves
5744     premove = gameMode == IcsPlayingWhite && !WhiteOnMove(currentMove) ||
5745               gameMode == IcsPlayingBlack &&  WhiteOnMove(currentMove);
5746     if(appData.testLegality && !premove) {
5747         moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
5748                         fromY, fromX, toY, toX, gameInfo.variant == VariantShogi ? '+' : NULLCHAR);
5749         if(moveType != WhitePromotion && moveType  != BlackPromotion)
5750             return FALSE;
5751     }
5752
5753     return TRUE;
5754 }
5755
5756 int
5757 InPalace(row, column)
5758      int row, column;
5759 {   /* [HGM] for Xiangqi */
5760     if( (row < 3 || row > BOARD_HEIGHT-4) &&
5761          column < (BOARD_WIDTH + 4)/2 &&
5762          column > (BOARD_WIDTH - 5)/2 ) return TRUE;
5763     return FALSE;
5764 }
5765
5766 int
5767 PieceForSquare (x, y)
5768      int x;
5769      int y;
5770 {
5771   if (x < 0 || x >= BOARD_WIDTH || y < 0 || y >= BOARD_HEIGHT)
5772      return -1;
5773   else
5774      return boards[currentMove][y][x];
5775 }
5776
5777 int
5778 OKToStartUserMove(x, y)
5779      int x, y;
5780 {
5781     ChessSquare from_piece;
5782     int white_piece;
5783
5784     if (matchMode) return FALSE;
5785     if (gameMode == EditPosition) return TRUE;
5786
5787     if (x >= 0 && y >= 0)
5788       from_piece = boards[currentMove][y][x];
5789     else
5790       from_piece = EmptySquare;
5791
5792     if (from_piece == EmptySquare) return FALSE;
5793
5794     white_piece = (int)from_piece >= (int)WhitePawn &&
5795       (int)from_piece < (int)BlackPawn; /* [HGM] can be > King! */
5796
5797     switch (gameMode) {
5798       case PlayFromGameFile:
5799       case AnalyzeFile:
5800       case TwoMachinesPlay:
5801       case EndOfGame:
5802         return FALSE;
5803
5804       case IcsObserving:
5805       case IcsIdle:
5806         return FALSE;
5807
5808       case MachinePlaysWhite:
5809       case IcsPlayingBlack:
5810         if (appData.zippyPlay) return FALSE;
5811         if (white_piece) {
5812             DisplayMoveError(_("You are playing Black"));
5813             return FALSE;
5814         }
5815         break;
5816
5817       case MachinePlaysBlack:
5818       case IcsPlayingWhite:
5819         if (appData.zippyPlay) return FALSE;
5820         if (!white_piece) {
5821             DisplayMoveError(_("You are playing White"));
5822             return FALSE;
5823         }
5824         break;
5825
5826       case EditGame:
5827         if (!white_piece && WhiteOnMove(currentMove)) {
5828             DisplayMoveError(_("It is White's turn"));
5829             return FALSE;
5830         }
5831         if (white_piece && !WhiteOnMove(currentMove)) {
5832             DisplayMoveError(_("It is Black's turn"));
5833             return FALSE;
5834         }
5835         if (cmailMsgLoaded && (currentMove < cmailOldMove)) {
5836             /* Editing correspondence game history */
5837             /* Could disallow this or prompt for confirmation */
5838             cmailOldMove = -1;
5839         }
5840         break;
5841
5842       case BeginningOfGame:
5843         if (appData.icsActive) return FALSE;
5844         if (!appData.noChessProgram) {
5845             if (!white_piece) {
5846                 DisplayMoveError(_("You are playing White"));
5847                 return FALSE;
5848             }
5849         }
5850         break;
5851
5852       case Training:
5853         if (!white_piece && WhiteOnMove(currentMove)) {
5854             DisplayMoveError(_("It is White's turn"));
5855             return FALSE;
5856         }
5857         if (white_piece && !WhiteOnMove(currentMove)) {
5858             DisplayMoveError(_("It is Black's turn"));
5859             return FALSE;
5860         }
5861         break;
5862
5863       default:
5864       case IcsExamining:
5865         break;
5866     }
5867     if (currentMove != forwardMostMove && gameMode != AnalyzeMode
5868         && gameMode != EditGame // [HGM] vari: treat as AnalyzeMode
5869         && gameMode != AnalyzeFile && gameMode != Training) {
5870         DisplayMoveError(_("Displayed position is not current"));
5871         return FALSE;
5872     }
5873     return TRUE;
5874 }
5875
5876 Boolean
5877 OnlyMove(int *x, int *y, Boolean captures) {
5878     DisambiguateClosure cl;
5879     if (appData.zippyPlay) return FALSE;
5880     switch(gameMode) {
5881       case MachinePlaysBlack:
5882       case IcsPlayingWhite:
5883       case BeginningOfGame:
5884         if(!WhiteOnMove(currentMove)) return FALSE;
5885         break;
5886       case MachinePlaysWhite:
5887       case IcsPlayingBlack:
5888         if(WhiteOnMove(currentMove)) return FALSE;
5889         break;
5890       case EditGame:
5891         break;
5892       default:
5893         return FALSE;
5894     }
5895     cl.pieceIn = EmptySquare;
5896     cl.rfIn = *y;
5897     cl.ffIn = *x;
5898     cl.rtIn = -1;
5899     cl.ftIn = -1;
5900     cl.promoCharIn = NULLCHAR;
5901     Disambiguate(boards[currentMove], PosFlags(currentMove), &cl);
5902     if( cl.kind == NormalMove ||
5903         cl.kind == AmbiguousMove && captures && cl.captures == 1 ||
5904         cl.kind == WhitePromotion || cl.kind == BlackPromotion ||
5905         cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) {
5906       fromX = cl.ff;
5907       fromY = cl.rf;
5908       *x = cl.ft;
5909       *y = cl.rt;
5910       return TRUE;
5911     }
5912     if(cl.kind != ImpossibleMove) return FALSE;
5913     cl.pieceIn = EmptySquare;
5914     cl.rfIn = -1;
5915     cl.ffIn = -1;
5916     cl.rtIn = *y;
5917     cl.ftIn = *x;
5918     cl.promoCharIn = NULLCHAR;
5919     Disambiguate(boards[currentMove], PosFlags(currentMove), &cl);
5920     if( cl.kind == NormalMove ||
5921         cl.kind == AmbiguousMove && captures && cl.captures == 1 ||
5922         cl.kind == WhitePromotion || cl.kind == BlackPromotion ||
5923         cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) {
5924       fromX = cl.ff;
5925       fromY = cl.rf;
5926       *x = cl.ft;
5927       *y = cl.rt;
5928       autoQueen = TRUE; // act as if autoQueen on when we click to-square
5929       return TRUE;
5930     }
5931     return FALSE;
5932 }
5933
5934 FILE *lastLoadGameFP = NULL, *lastLoadPositionFP = NULL;
5935 int lastLoadGameNumber = 0, lastLoadPositionNumber = 0;
5936 int lastLoadGameUseList = FALSE;
5937 char lastLoadGameTitle[MSG_SIZ], lastLoadPositionTitle[MSG_SIZ];
5938 ChessMove lastLoadGameStart = EndOfFile;
5939
5940 void
5941 UserMoveEvent(fromX, fromY, toX, toY, promoChar)
5942      int fromX, fromY, toX, toY;
5943      int promoChar;
5944 {
5945     ChessMove moveType;
5946     ChessSquare pdown, pup;
5947
5948     /* Check if the user is playing in turn.  This is complicated because we
5949        let the user "pick up" a piece before it is his turn.  So the piece he
5950        tried to pick up may have been captured by the time he puts it down!
5951        Therefore we use the color the user is supposed to be playing in this
5952        test, not the color of the piece that is currently on the starting
5953        square---except in EditGame mode, where the user is playing both
5954        sides; fortunately there the capture race can't happen.  (It can
5955        now happen in IcsExamining mode, but that's just too bad.  The user
5956        will get a somewhat confusing message in that case.)
5957        */
5958
5959     switch (gameMode) {
5960       case PlayFromGameFile:
5961       case AnalyzeFile:
5962       case TwoMachinesPlay:
5963       case EndOfGame:
5964       case IcsObserving:
5965       case IcsIdle:
5966         /* We switched into a game mode where moves are not accepted,
5967            perhaps while the mouse button was down. */
5968         return;
5969
5970       case MachinePlaysWhite:
5971         /* User is moving for Black */
5972         if (WhiteOnMove(currentMove)) {
5973             DisplayMoveError(_("It is White's turn"));
5974             return;
5975         }
5976         break;
5977
5978       case MachinePlaysBlack:
5979         /* User is moving for White */
5980         if (!WhiteOnMove(currentMove)) {
5981             DisplayMoveError(_("It is Black's turn"));
5982             return;
5983         }
5984         break;
5985
5986       case EditGame:
5987       case IcsExamining:
5988       case BeginningOfGame:
5989       case AnalyzeMode:
5990       case Training:
5991         if ((int) boards[currentMove][fromY][fromX] >= (int) BlackPawn &&
5992             (int) boards[currentMove][fromY][fromX] < (int) EmptySquare) {
5993             /* User is moving for Black */
5994             if (WhiteOnMove(currentMove)) {
5995                 DisplayMoveError(_("It is White's turn"));
5996                 return;
5997             }
5998         } else {
5999             /* User is moving for White */
6000             if (!WhiteOnMove(currentMove)) {
6001                 DisplayMoveError(_("It is Black's turn"));
6002                 return;
6003             }
6004         }
6005         break;
6006
6007       case IcsPlayingBlack:
6008         /* User is moving for Black */
6009         if (WhiteOnMove(currentMove)) {
6010             if (!appData.premove) {
6011                 DisplayMoveError(_("It is White's turn"));
6012             } else if (toX >= 0 && toY >= 0) {
6013                 premoveToX = toX;
6014                 premoveToY = toY;
6015                 premoveFromX = fromX;
6016                 premoveFromY = fromY;
6017                 premovePromoChar = promoChar;
6018                 gotPremove = 1;
6019                 if (appData.debugMode)
6020                     fprintf(debugFP, "Got premove: fromX %d,"
6021                             "fromY %d, toX %d, toY %d\n",
6022                             fromX, fromY, toX, toY);
6023             }
6024             return;
6025         }
6026         break;
6027
6028       case IcsPlayingWhite:
6029         /* User is moving for White */
6030         if (!WhiteOnMove(currentMove)) {
6031             if (!appData.premove) {
6032                 DisplayMoveError(_("It is Black's turn"));
6033             } else if (toX >= 0 && toY >= 0) {
6034                 premoveToX = toX;
6035                 premoveToY = toY;
6036                 premoveFromX = fromX;
6037                 premoveFromY = fromY;
6038                 premovePromoChar = promoChar;
6039                 gotPremove = 1;
6040                 if (appData.debugMode)
6041                     fprintf(debugFP, "Got premove: fromX %d,"
6042                             "fromY %d, toX %d, toY %d\n",
6043                             fromX, fromY, toX, toY);
6044             }
6045             return;
6046         }
6047         break;
6048
6049       default:
6050         break;
6051
6052       case EditPosition:
6053         /* EditPosition, empty square, or different color piece;
6054            click-click move is possible */
6055         if (toX == -2 || toY == -2) {
6056             boards[0][fromY][fromX] = EmptySquare;
6057             DrawPosition(FALSE, boards[currentMove]);
6058             return;
6059         } else if (toX >= 0 && toY >= 0) {
6060             boards[0][toY][toX] = boards[0][fromY][fromX];
6061             if(fromX == BOARD_LEFT-2) { // handle 'moves' out of holdings
6062                 if(boards[0][fromY][0] != EmptySquare) {
6063                     if(boards[0][fromY][1]) boards[0][fromY][1]--;
6064                     if(boards[0][fromY][1] == 0)  boards[0][fromY][0] = EmptySquare;
6065                 }
6066             } else
6067             if(fromX == BOARD_RGHT+1) {
6068                 if(boards[0][fromY][BOARD_WIDTH-1] != EmptySquare) {
6069                     if(boards[0][fromY][BOARD_WIDTH-2]) boards[0][fromY][BOARD_WIDTH-2]--;
6070                     if(boards[0][fromY][BOARD_WIDTH-2] == 0)  boards[0][fromY][BOARD_WIDTH-1] = EmptySquare;
6071                 }
6072             } else
6073             boards[0][fromY][fromX] = EmptySquare;
6074             DrawPosition(FALSE, boards[currentMove]);
6075             return;
6076         }
6077         return;
6078     }
6079
6080     if(toX < 0 || toY < 0) return;
6081     pdown = boards[currentMove][fromY][fromX];
6082     pup = boards[currentMove][toY][toX];
6083
6084     /* [HGM] If move started in holdings, it means a drop. Convert to standard form */
6085     if( fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) {
6086          if( pup != EmptySquare ) return;
6087          moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
6088            if(appData.debugMode) fprintf(debugFP, "Drop move %d, curr=%d, x=%d,y=%d, p=%d\n",
6089                 moveType, currentMove, fromX, fromY, boards[currentMove][fromY][fromX]);
6090            // holdings might not be sent yet in ICS play; we have to figure out which piece belongs here
6091            if(fromX == 0) fromY = BOARD_HEIGHT-1 - fromY; // black holdings upside-down
6092            fromX = fromX ? WhitePawn : BlackPawn; // first piece type in selected holdings
6093            while(PieceToChar(fromX) == '.' || PieceToNumber(fromX) != fromY && fromX != (int) EmptySquare) fromX++;
6094          fromY = DROP_RANK;
6095     }
6096
6097     /* [HGM] always test for legality, to get promotion info */
6098     moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
6099                                          fromY, fromX, toY, toX, promoChar);
6100     /* [HGM] but possibly ignore an IllegalMove result */
6101     if (appData.testLegality) {
6102         if (moveType == IllegalMove || moveType == ImpossibleMove) {
6103             DisplayMoveError(_("Illegal move"));
6104             return;
6105         }
6106     }
6107
6108     FinishMove(moveType, fromX, fromY, toX, toY, promoChar);
6109 }
6110
6111 /* Common tail of UserMoveEvent and DropMenuEvent */
6112 int
6113 FinishMove(moveType, fromX, fromY, toX, toY, promoChar)
6114      ChessMove moveType;
6115      int fromX, fromY, toX, toY;
6116      /*char*/int promoChar;
6117 {
6118     char *bookHit = 0;
6119
6120     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) && promoChar != NULLCHAR) {
6121         // [HGM] superchess: suppress promotions to non-available piece
6122         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
6123         if(WhiteOnMove(currentMove)) {
6124             if(!boards[currentMove][k][BOARD_WIDTH-2]) return 0;
6125         } else {
6126             if(!boards[currentMove][BOARD_HEIGHT-1-k][1]) return 0;
6127         }
6128     }
6129
6130     /* [HGM] <popupFix> kludge to avoid having to know the exact promotion
6131        move type in caller when we know the move is a legal promotion */
6132     if(moveType == NormalMove && promoChar)
6133         moveType = WhiteOnMove(currentMove) ? WhitePromotion : BlackPromotion;
6134
6135     /* [HGM] <popupFix> The following if has been moved here from
6136        UserMoveEvent(). Because it seemed to belong here (why not allow
6137        piece drops in training games?), and because it can only be
6138        performed after it is known to what we promote. */
6139     if (gameMode == Training) {
6140       /* compare the move played on the board to the next move in the
6141        * game. If they match, display the move and the opponent's response.
6142        * If they don't match, display an error message.
6143        */
6144       int saveAnimate;
6145       Board testBoard;
6146       CopyBoard(testBoard, boards[currentMove]);
6147       ApplyMove(fromX, fromY, toX, toY, promoChar, testBoard);
6148
6149       if (CompareBoards(testBoard, boards[currentMove+1])) {
6150         ForwardInner(currentMove+1);
6151
6152         /* Autoplay the opponent's response.
6153          * if appData.animate was TRUE when Training mode was entered,
6154          * the response will be animated.
6155          */
6156         saveAnimate = appData.animate;
6157         appData.animate = animateTraining;
6158         ForwardInner(currentMove+1);
6159         appData.animate = saveAnimate;
6160
6161         /* check for the end of the game */
6162         if (currentMove >= forwardMostMove) {
6163           gameMode = PlayFromGameFile;
6164           ModeHighlight();
6165           SetTrainingModeOff();
6166           DisplayInformation(_("End of game"));
6167         }
6168       } else {
6169         DisplayError(_("Incorrect move"), 0);
6170       }
6171       return 1;
6172     }
6173
6174   /* Ok, now we know that the move is good, so we can kill
6175      the previous line in Analysis Mode */
6176   if ((gameMode == AnalyzeMode || gameMode == EditGame)
6177                                 && currentMove < forwardMostMove) {
6178     if(appData.variations && shiftKey) PushTail(currentMove, forwardMostMove); // [HGM] vari: save tail of game
6179     else forwardMostMove = currentMove;
6180   }
6181
6182   /* If we need the chess program but it's dead, restart it */
6183   ResurrectChessProgram();
6184
6185   /* A user move restarts a paused game*/
6186   if (pausing)
6187     PauseEvent();
6188
6189   thinkOutput[0] = NULLCHAR;
6190
6191   MakeMove(fromX, fromY, toX, toY, promoChar); /*updates forwardMostMove*/
6192
6193   if(Adjudicate(NULL)) return 1; // [HGM] adjudicate: take care of automtic game end
6194
6195   if (gameMode == BeginningOfGame) {
6196     if (appData.noChessProgram) {
6197       gameMode = EditGame;
6198       SetGameInfo();
6199     } else {
6200       char buf[MSG_SIZ];
6201       gameMode = MachinePlaysBlack;
6202       StartClocks();
6203       SetGameInfo();
6204       snprintf(buf, MSG_SIZ, "%s vs. %s", gameInfo.white, gameInfo.black);
6205       DisplayTitle(buf);
6206       if (first.sendName) {
6207         snprintf(buf, MSG_SIZ,"name %s\n", gameInfo.white);
6208         SendToProgram(buf, &first);
6209       }
6210       StartClocks();
6211     }
6212     ModeHighlight();
6213   }
6214
6215   /* Relay move to ICS or chess engine */
6216   if (appData.icsActive) {
6217     if (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
6218         gameMode == IcsExamining) {
6219       if(userOfferedDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
6220         SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
6221         SendToICS("draw ");
6222         SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
6223       }
6224       // also send plain move, in case ICS does not understand atomic claims
6225       SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
6226       ics_user_moved = 1;
6227     }
6228   } else {
6229     if (first.sendTime && (gameMode == BeginningOfGame ||
6230                            gameMode == MachinePlaysWhite ||
6231                            gameMode == MachinePlaysBlack)) {
6232       SendTimeRemaining(&first, gameMode != MachinePlaysBlack);
6233     }
6234     if (gameMode != EditGame && gameMode != PlayFromGameFile) {
6235          // [HGM] book: if program might be playing, let it use book
6236         bookHit = SendMoveToBookUser(forwardMostMove-1, &first, FALSE);
6237         first.maybeThinking = TRUE;
6238     } else SendMoveToProgram(forwardMostMove-1, &first);
6239     if (currentMove == cmailOldMove + 1) {
6240       cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
6241     }
6242   }
6243
6244   ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6245
6246   switch (gameMode) {
6247   case EditGame:
6248     switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
6249     case MT_NONE:
6250     case MT_CHECK:
6251       break;
6252     case MT_CHECKMATE:
6253     case MT_STAINMATE:
6254       if (WhiteOnMove(currentMove)) {
6255         GameEnds(BlackWins, "Black mates", GE_PLAYER);
6256       } else {
6257         GameEnds(WhiteWins, "White mates", GE_PLAYER);
6258       }
6259       break;
6260     case MT_STALEMATE:
6261       GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
6262       break;
6263     }
6264     break;
6265
6266   case MachinePlaysBlack:
6267   case MachinePlaysWhite:
6268     /* disable certain menu options while machine is thinking */
6269     SetMachineThinkingEnables();
6270     break;
6271
6272   default:
6273     break;
6274   }
6275
6276   userOfferedDraw = FALSE; // [HGM] drawclaim: after move made, and tested for claimable draw
6277
6278   if(bookHit) { // [HGM] book: simulate book reply
6279         static char bookMove[MSG_SIZ]; // a bit generous?
6280
6281         programStats.nodes = programStats.depth = programStats.time =
6282         programStats.score = programStats.got_only_move = 0;
6283         sprintf(programStats.movelist, "%s (xbook)", bookHit);
6284
6285         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
6286         strcat(bookMove, bookHit);
6287         HandleMachineMove(bookMove, &first);
6288   }
6289   return 1;
6290 }
6291
6292 void
6293 Mark(board, flags, kind, rf, ff, rt, ft, closure)
6294      Board board;
6295      int flags;
6296      ChessMove kind;
6297      int rf, ff, rt, ft;
6298      VOIDSTAR closure;
6299 {
6300     typedef char Markers[BOARD_RANKS][BOARD_FILES];
6301     Markers *m = (Markers *) closure;
6302     if(rf == fromY && ff == fromX)
6303         (*m)[rt][ft] = 1 + (board[rt][ft] != EmptySquare
6304                          || kind == WhiteCapturesEnPassant
6305                          || kind == BlackCapturesEnPassant);
6306     else if(flags & F_MANDATORY_CAPTURE && board[rt][ft] != EmptySquare) (*m)[rt][ft] = 3;
6307 }
6308
6309 void
6310 MarkTargetSquares(int clear)
6311 {
6312   int x, y;
6313   if(!appData.markers || !appData.highlightDragging ||
6314      !appData.testLegality || gameMode == EditPosition) return;
6315   if(clear) {
6316     for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) marker[y][x] = 0;
6317   } else {
6318     int capt = 0;
6319     GenLegal(boards[currentMove], PosFlags(currentMove), Mark, (void*) marker);
6320     if(PosFlags(0) & F_MANDATORY_CAPTURE) {
6321       for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) if(marker[y][x]>1) capt++;
6322       if(capt)
6323       for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) if(marker[y][x] == 1) marker[y][x] = 0;
6324     }
6325   }
6326   DrawPosition(TRUE, NULL);
6327 }
6328
6329 int
6330 Explode(Board board, int fromX, int fromY, int toX, int toY)
6331 {
6332     if(gameInfo.variant == VariantAtomic &&
6333        (board[toY][toX] != EmptySquare ||                     // capture?
6334         toX != fromX && (board[fromY][fromX] == WhitePawn ||  // e.p. ?
6335                          board[fromY][fromX] == BlackPawn   )
6336       )) {
6337         AnimateAtomicCapture(board, fromX, fromY, toX, toY);
6338         return TRUE;
6339     }
6340     return FALSE;
6341 }
6342
6343 ChessSquare gatingPiece = EmptySquare; // exported to front-end, for dragging
6344
6345 void LeftClick(ClickType clickType, int xPix, int yPix)
6346 {
6347     int x, y;
6348     Boolean saveAnimate;
6349     static int second = 0, promotionChoice = 0, dragging = 0;
6350     char promoChoice = NULLCHAR;
6351
6352     if(appData.seekGraph && appData.icsActive && loggedOn &&
6353         (gameMode == BeginningOfGame || gameMode == IcsIdle)) {
6354         SeekGraphClick(clickType, xPix, yPix, 0);
6355         return;
6356     }
6357
6358     if (clickType == Press) ErrorPopDown();
6359     MarkTargetSquares(1);
6360
6361     x = EventToSquare(xPix, BOARD_WIDTH);
6362     y = EventToSquare(yPix, BOARD_HEIGHT);
6363     if (!flipView && y >= 0) {
6364         y = BOARD_HEIGHT - 1 - y;
6365     }
6366     if (flipView && x >= 0) {
6367         x = BOARD_WIDTH - 1 - x;
6368     }
6369
6370     if(promotionChoice) { // we are waiting for a click to indicate promotion piece
6371         if(clickType == Release) return; // ignore upclick of click-click destination
6372         promotionChoice = FALSE; // only one chance: if click not OK it is interpreted as cancel
6373         if(appData.debugMode) fprintf(debugFP, "promotion click, x=%d, y=%d\n", x, y);
6374         if(gameInfo.holdingsWidth &&
6375                 (WhiteOnMove(currentMove)
6376                         ? x == BOARD_WIDTH-1 && y < gameInfo.holdingsSize && y > 0
6377                         : x == 0 && y >= BOARD_HEIGHT - gameInfo.holdingsSize && y < BOARD_HEIGHT-1) ) {
6378             // click in right holdings, for determining promotion piece
6379             ChessSquare p = boards[currentMove][y][x];
6380             if(appData.debugMode) fprintf(debugFP, "square contains %d\n", (int)p);
6381             if(p != EmptySquare) {
6382                 FinishMove(NormalMove, fromX, fromY, toX, toY, ToLower(PieceToChar(p)));
6383                 fromX = fromY = -1;
6384                 return;
6385             }
6386         }
6387         DrawPosition(FALSE, boards[currentMove]);
6388         return;
6389     }
6390
6391     /* [HGM] holdings: next 5 lines: ignore all clicks between board and holdings */
6392     if(clickType == Press
6393             && ( x == BOARD_LEFT-1 || x == BOARD_RGHT
6394               || x == BOARD_LEFT-2 && y < BOARD_HEIGHT-gameInfo.holdingsSize
6395               || x == BOARD_RGHT+1 && y >= gameInfo.holdingsSize) )
6396         return;
6397
6398     autoQueen = appData.alwaysPromoteToQueen;
6399
6400     if (fromX == -1) {
6401       gatingPiece = EmptySquare;
6402       if (clickType != Press) {
6403         if(dragging) { // [HGM] from-square must have been reset due to game end since last press
6404             DragPieceEnd(xPix, yPix); dragging = 0;
6405             DrawPosition(FALSE, NULL);
6406         }
6407         return;
6408       }
6409       if(!appData.oneClick || !OnlyMove(&x, &y, FALSE)) {
6410             /* First square */
6411             if (OKToStartUserMove(x, y)) {
6412                 fromX = x;
6413                 fromY = y;
6414                 second = 0;
6415                 MarkTargetSquares(0);
6416                 DragPieceBegin(xPix, yPix); dragging = 1;
6417                 if (appData.highlightDragging) {
6418                     SetHighlights(x, y, -1, -1);
6419                 }
6420             }
6421             return;
6422         }
6423     }
6424
6425     /* fromX != -1 */
6426     if (clickType == Press && gameMode != EditPosition) {
6427         ChessSquare fromP;
6428         ChessSquare toP;
6429         int frc;
6430
6431         // ignore off-board to clicks
6432         if(y < 0 || x < 0) return;
6433
6434         /* Check if clicking again on the same color piece */
6435         fromP = boards[currentMove][fromY][fromX];
6436         toP = boards[currentMove][y][x];
6437         frc = gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom || gameInfo.variant == VariantSChess;
6438         if ((WhitePawn <= fromP && fromP <= WhiteKing &&
6439              WhitePawn <= toP && toP <= WhiteKing &&
6440              !(fromP == WhiteKing && toP == WhiteRook && frc) &&
6441              !(fromP == WhiteRook && toP == WhiteKing && frc)) ||
6442             (BlackPawn <= fromP && fromP <= BlackKing &&
6443              BlackPawn <= toP && toP <= BlackKing &&
6444              !(fromP == BlackRook && toP == BlackKing && frc) && // allow also RxK as FRC castling
6445              !(fromP == BlackKing && toP == BlackRook && frc))) {
6446             /* Clicked again on same color piece -- changed his mind */
6447             second = (x == fromX && y == fromY);
6448            if(!second || appData.oneClick && !OnlyMove(&x, &y, TRUE)) {
6449             if (appData.highlightDragging) {
6450                 SetHighlights(x, y, -1, -1);
6451             } else {
6452                 ClearHighlights();
6453             }
6454             if (OKToStartUserMove(x, y)) {
6455                 if(gameInfo.variant == VariantSChess && // S-Chess: back-rank piece selected after holdings means gating
6456                   (fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) &&
6457                y == (toP < BlackPawn ? 0 : BOARD_HEIGHT-1))
6458                  gatingPiece = boards[currentMove][fromY][fromX];
6459                 else gatingPiece = EmptySquare;
6460                 fromX = x;
6461                 fromY = y; dragging = 1;
6462                 MarkTargetSquares(0);
6463                 DragPieceBegin(xPix, yPix);
6464             }
6465            }
6466            if(x == fromX && y == fromY) return; // if OnlyMove altered (x,y) we go on
6467            second = FALSE;
6468         }
6469         // ignore clicks on holdings
6470         if(x < BOARD_LEFT || x >= BOARD_RGHT) return;
6471     }
6472
6473     if (clickType == Release && x == fromX && y == fromY) {
6474         DragPieceEnd(xPix, yPix); dragging = 0;
6475         if (appData.animateDragging) {
6476             /* Undo animation damage if any */
6477             DrawPosition(FALSE, NULL);
6478         }
6479         if (second) {
6480             /* Second up/down in same square; just abort move */
6481             second = 0;
6482             fromX = fromY = -1;
6483             gatingPiece = EmptySquare;
6484             ClearHighlights();
6485             gotPremove = 0;
6486             ClearPremoveHighlights();
6487         } else {
6488             /* First upclick in same square; start click-click mode */
6489             SetHighlights(x, y, -1, -1);
6490         }
6491         return;
6492     }
6493
6494     /* we now have a different from- and (possibly off-board) to-square */
6495     /* Completed move */
6496     toX = x;
6497     toY = y;
6498     saveAnimate = appData.animate;
6499     if (clickType == Press) {
6500         /* Finish clickclick move */
6501         if (appData.animate || appData.highlightLastMove) {
6502             SetHighlights(fromX, fromY, toX, toY);
6503         } else {
6504             ClearHighlights();
6505         }
6506     } else {
6507         /* Finish drag move */
6508         if (appData.highlightLastMove) {
6509             SetHighlights(fromX, fromY, toX, toY);
6510         } else {
6511             ClearHighlights();
6512         }
6513         DragPieceEnd(xPix, yPix); dragging = 0;
6514         /* Don't animate move and drag both */
6515         appData.animate = FALSE;
6516     }
6517
6518     // moves into holding are invalid for now (except in EditPosition, adapting to-square)
6519     if(x >= 0 && x < BOARD_LEFT || x >= BOARD_RGHT) {
6520         ChessSquare piece = boards[currentMove][fromY][fromX];
6521         if(gameMode == EditPosition && piece != EmptySquare &&
6522            fromX >= BOARD_LEFT && fromX < BOARD_RGHT) {
6523             int n;
6524
6525             if(x == BOARD_LEFT-2 && piece >= BlackPawn) {
6526                 n = PieceToNumber(piece - (int)BlackPawn);
6527                 if(n >= gameInfo.holdingsSize) { n = 0; piece = BlackPawn; }
6528                 boards[currentMove][BOARD_HEIGHT-1 - n][0] = piece;
6529                 boards[currentMove][BOARD_HEIGHT-1 - n][1]++;
6530             } else
6531             if(x == BOARD_RGHT+1 && piece < BlackPawn) {
6532                 n = PieceToNumber(piece);
6533                 if(n >= gameInfo.holdingsSize) { n = 0; piece = WhitePawn; }
6534                 boards[currentMove][n][BOARD_WIDTH-1] = piece;
6535                 boards[currentMove][n][BOARD_WIDTH-2]++;
6536             }
6537             boards[currentMove][fromY][fromX] = EmptySquare;
6538         }
6539         ClearHighlights();
6540         fromX = fromY = -1;
6541         DrawPosition(TRUE, boards[currentMove]);
6542         return;
6543     }
6544
6545     // off-board moves should not be highlighted
6546     if(x < 0 || y < 0) ClearHighlights();
6547
6548     if(gatingPiece != EmptySquare) promoChoice = ToLower(PieceToChar(gatingPiece));
6549
6550     if (HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice)) {
6551         SetHighlights(fromX, fromY, toX, toY);
6552         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
6553             // [HGM] super: promotion to captured piece selected from holdings
6554             ChessSquare p = boards[currentMove][fromY][fromX], q = boards[currentMove][toY][toX];
6555             promotionChoice = TRUE;
6556             // kludge follows to temporarily execute move on display, without promoting yet
6557             boards[currentMove][fromY][fromX] = EmptySquare; // move Pawn to 8th rank
6558             boards[currentMove][toY][toX] = p;
6559             DrawPosition(FALSE, boards[currentMove]);
6560             boards[currentMove][fromY][fromX] = p; // take back, but display stays
6561             boards[currentMove][toY][toX] = q;
6562             DisplayMessage("Click in holdings to choose piece", "");
6563             return;
6564         }
6565         PromotionPopUp();
6566     } else {
6567         int oldMove = currentMove;
6568         UserMoveEvent(fromX, fromY, toX, toY, promoChoice);
6569         if (!appData.highlightLastMove || gotPremove) ClearHighlights();
6570         if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
6571         if(saveAnimate && !appData.animate && currentMove != oldMove && // drag-move was performed
6572            Explode(boards[currentMove-1], fromX, fromY, toX, toY))
6573             DrawPosition(TRUE, boards[currentMove]);
6574         fromX = fromY = -1;
6575     }
6576     appData.animate = saveAnimate;
6577     if (appData.animate || appData.animateDragging) {
6578         /* Undo animation damage if needed */
6579         DrawPosition(FALSE, NULL);
6580     }
6581 }
6582
6583 int RightClick(ClickType action, int x, int y, int *fromX, int *fromY)
6584 {   // front-end-free part taken out of PieceMenuPopup
6585     int whichMenu; int xSqr, ySqr;
6586
6587     if(seekGraphUp) { // [HGM] seekgraph
6588         if(action == Press)   SeekGraphClick(Press, x, y, 2); // 2 indicates right-click: no pop-down on miss
6589         if(action == Release) SeekGraphClick(Release, x, y, 2); // and no challenge on hit
6590         return -2;
6591     }
6592
6593     if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)
6594          && !appData.zippyPlay && appData.bgObserve) { // [HGM] bughouse: show background game
6595         if(!partnerBoardValid) return -2; // suppress display of uninitialized boards
6596         if( appData.dualBoard) return -2; // [HGM] dual: is already displayed
6597         if(action == Press)   {
6598             originalFlip = flipView;
6599             flipView = !flipView; // temporarily flip board to see game from partners perspective
6600             DrawPosition(TRUE, partnerBoard);
6601             DisplayMessage(partnerStatus, "");
6602             partnerUp = TRUE;
6603         } else if(action == Release) {
6604             flipView = originalFlip;
6605             DrawPosition(TRUE, boards[currentMove]);
6606             partnerUp = FALSE;
6607         }
6608         return -2;
6609     }
6610
6611     xSqr = EventToSquare(x, BOARD_WIDTH);
6612     ySqr = EventToSquare(y, BOARD_HEIGHT);
6613     if (action == Release) UnLoadPV(); // [HGM] pv
6614     if (action != Press) return -2; // return code to be ignored
6615     switch (gameMode) {
6616       case IcsExamining:
6617         if(xSqr < BOARD_LEFT || xSqr >= BOARD_RGHT) return -1;\r
6618       case EditPosition:
6619         if (xSqr == BOARD_LEFT-1 || xSqr == BOARD_RGHT) return -1;\r
6620         if (xSqr < 0 || ySqr < 0) return -1;\r
6621         whichMenu = 0; // edit-position menu
6622         break;
6623       case IcsObserving:
6624         if(!appData.icsEngineAnalyze) return -1;
6625       case IcsPlayingWhite:
6626       case IcsPlayingBlack:
6627         if(!appData.zippyPlay) goto noZip;
6628       case AnalyzeMode:
6629       case AnalyzeFile:
6630       case MachinePlaysWhite:
6631       case MachinePlaysBlack:
6632       case TwoMachinesPlay: // [HGM] pv: use for showing PV
6633         if (!appData.dropMenu) {
6634           LoadPV(x, y);
6635           return 2; // flag front-end to grab mouse events
6636         }
6637         if(gameMode == TwoMachinesPlay || gameMode == AnalyzeMode ||
6638            gameMode == AnalyzeFile || gameMode == IcsObserving) return -1;
6639       case EditGame:
6640       noZip:
6641         if (xSqr < 0 || ySqr < 0) return -1;
6642         if (!appData.dropMenu || appData.testLegality &&
6643             gameInfo.variant != VariantBughouse &&
6644             gameInfo.variant != VariantCrazyhouse) return -1;
6645         whichMenu = 1; // drop menu
6646         break;
6647       default:
6648         return -1;
6649     }
6650
6651     if (((*fromX = xSqr) < 0) ||
6652         ((*fromY = ySqr) < 0)) {
6653         *fromX = *fromY = -1;
6654         return -1;
6655     }
6656     if (flipView)
6657       *fromX = BOARD_WIDTH - 1 - *fromX;
6658     else
6659       *fromY = BOARD_HEIGHT - 1 - *fromY;
6660
6661     return whichMenu;
6662 }
6663
6664 void SendProgramStatsToFrontend( ChessProgramState * cps, ChessProgramStats * cpstats )
6665 {
6666 //    char * hint = lastHint;
6667     FrontEndProgramStats stats;
6668
6669     stats.which = cps == &first ? 0 : 1;
6670     stats.depth = cpstats->depth;
6671     stats.nodes = cpstats->nodes;
6672     stats.score = cpstats->score;
6673     stats.time = cpstats->time;
6674     stats.pv = cpstats->movelist;
6675     stats.hint = lastHint;
6676     stats.an_move_index = 0;
6677     stats.an_move_count = 0;
6678
6679     if( gameMode == AnalyzeMode || gameMode == AnalyzeFile ) {
6680         stats.hint = cpstats->move_name;
6681         stats.an_move_index = cpstats->nr_moves - cpstats->moves_left;
6682         stats.an_move_count = cpstats->nr_moves;
6683     }
6684
6685     if(stats.pv && stats.pv[0]) safeStrCpy(lastPV[stats.which], stats.pv, sizeof(lastPV[stats.which])/sizeof(lastPV[stats.which][0])); // [HGM] pv: remember last PV of each
6686
6687     SetProgramStats( &stats );
6688 }
6689
6690 void
6691 Count(Board board, int pCnt[], int *nW, int *nB, int *wStale, int *bStale, int *bishopColor)
6692 {       // count all piece types
6693         int p, f, r;
6694         *nB = *nW = *wStale = *bStale = *bishopColor = 0;
6695         for(p=WhitePawn; p<=EmptySquare; p++) pCnt[p] = 0;
6696         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
6697                 p = board[r][f];
6698                 pCnt[p]++;
6699                 if(p == WhitePawn && r == BOARD_HEIGHT-1) (*wStale)++; else
6700                 if(p == BlackPawn && r == 0) (*bStale)++; // count last-Rank Pawns (XQ) separately
6701                 if(p <= WhiteKing) (*nW)++; else if(p <= BlackKing) (*nB)++;
6702                 if(p == WhiteBishop || p == WhiteFerz || p == WhiteAlfil ||
6703                    p == BlackBishop || p == BlackFerz || p == BlackAlfil   )
6704                         *bishopColor |= 1 << ((f^r)&1); // track square color of color-bound pieces
6705         }
6706 }
6707
6708 int
6709 SufficientDefence(int pCnt[], int side, int nMine, int nHis)
6710 {
6711         int myPawns = pCnt[WhitePawn+side]; // my total Pawn count;
6712         int majorDefense = pCnt[BlackRook-side] + pCnt[BlackCannon-side] + pCnt[BlackKnight-side];
6713
6714         nMine -= pCnt[WhiteFerz+side] + pCnt[WhiteAlfil+side]; // discount defenders
6715         if(nMine - myPawns > 2) return FALSE; // no trivial draws with more than 1 major
6716         if(myPawns == 2 && nMine == 3) // KPP
6717             return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] >= 3;
6718         if(myPawns == 1 && nMine == 2) // KP
6719             return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side]  + pCnt[BlackPawn-side] >= 1;
6720         if(myPawns == 1 && nMine == 3 && pCnt[WhiteKnight+side]) // KHP
6721             return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side]*2 >= 5;
6722         if(myPawns) return FALSE;
6723         if(pCnt[WhiteRook+side])
6724             return pCnt[BlackRook-side] ||
6725                    pCnt[BlackCannon-side] && (pCnt[BlackFerz-side] >= 2 || pCnt[BlackAlfil-side] >= 2) ||
6726                    pCnt[BlackKnight-side] && pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] > 2 ||
6727                    pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] >= 4;
6728         if(pCnt[WhiteCannon+side]) {
6729             if(pCnt[WhiteFerz+side] + myPawns == 0) return TRUE; // Cannon needs platform
6730             return majorDefense || pCnt[BlackAlfil-side] >= 2;
6731         }
6732         if(pCnt[WhiteKnight+side])
6733             return majorDefense || pCnt[BlackFerz-side] >= 2 || pCnt[BlackAlfil-side] + pCnt[BlackPawn-side] >= 1;
6734         return FALSE;
6735 }
6736
6737 int
6738 MatingPotential(int pCnt[], int side, int nMine, int nHis, int stale, int bisColor)
6739 {
6740         VariantClass v = gameInfo.variant;
6741
6742         if(v == VariantShogi || v == VariantCrazyhouse || v == VariantBughouse) return TRUE; // drop games always winnable
6743         if(v == VariantShatranj) return TRUE; // always winnable through baring
6744         if(v == VariantLosers || v == VariantSuicide || v == VariantGiveaway) return TRUE;
6745         if(v == Variant3Check || v == VariantAtomic) return nMine > 1; // can win through checking / exploding King
6746
6747         if(v == VariantXiangqi) {
6748                 int majors = 5*pCnt[BlackKnight-side] + 7*pCnt[BlackCannon-side] + 7*pCnt[BlackRook-side];
6749
6750                 nMine -= pCnt[WhiteFerz+side] + pCnt[WhiteAlfil+side] + stale; // discount defensive pieces and back-rank Pawns
6751                 if(nMine + stale == 1) return (pCnt[BlackFerz-side] > 1 && pCnt[BlackKnight-side] > 0); // bare K can stalemate KHAA (!)
6752                 if(nMine > 2) return TRUE; // if we don't have P, H or R, we must have CC
6753                 if(nMine == 2 && pCnt[WhiteCannon+side] == 0) return TRUE; // We have at least one P, H or R
6754                 // if we get here, we must have KC... or KP..., possibly with additional A, E or last-rank P
6755                 if(stale) // we have at least one last-rank P plus perhaps C
6756                     return majors // KPKX
6757                         || pCnt[BlackFerz-side] && pCnt[BlackFerz-side] + pCnt[WhiteCannon+side] + stale > 2; // KPKAA, KPPKA and KCPKA
6758                 else // KCA*E*
6759                     return pCnt[WhiteFerz+side] // KCAK
6760                         || pCnt[WhiteAlfil+side] && pCnt[BlackRook-side] + pCnt[BlackCannon-side] + pCnt[BlackFerz-side] // KCEKA, KCEKX (X!=H)
6761                         || majors + (12*pCnt[BlackFerz-side] | 6*pCnt[BlackAlfil-side]) > 16; // KCKAA, KCKAX, KCKEEX, KCKEXX (XX!=HH), KCKXXX
6762                 // TO DO: cases wih an unpromoted f-Pawn acting as platform for an opponent Cannon
6763
6764         } else if(pCnt[WhiteKing] == 1 && pCnt[BlackKing] == 1) { // other variants with orthodox Kings
6765                 int nBishops = pCnt[WhiteBishop+side] + pCnt[WhiteFerz+side];
6766
6767                 if(nMine == 1) return FALSE; // bare King
6768                 if(nBishops && bisColor == 3) return TRUE; // There must be a second B/A/F, which can either block (his) or attack (mine) the escape square
6769                 nMine += (nBishops > 0) - nBishops; // By now all Bishops (and Ferz) on like-colored squares, so count as one
6770                 if(nMine > 2 && nMine != pCnt[WhiteAlfil+side] + 1) return TRUE; // At least two pieces, not all Alfils
6771                 // by now we have King + 1 piece (or multiple Bishops on the same color)
6772                 if(pCnt[WhiteKnight+side])
6773                         return (pCnt[BlackKnight-side] + pCnt[BlackBishop-side] + pCnt[BlackMan-side] +
6774                                 pCnt[BlackWazir-side] + pCnt[BlackSilver-side] + bisColor // KNKN, KNKB, KNKF, KNKE, KNKW, KNKM, KNKS
6775                              || nHis > 3); // be sure to cover suffocation mates in corner (e.g. KNKQCA)
6776                 if(nBishops)
6777                         return (pCnt[BlackKnight-side]); // KBKN, KFKN
6778                 if(pCnt[WhiteAlfil+side])
6779                         return (nHis > 2); // Alfils can in general not reach a corner square, but there might be edge (suffocation) mates
6780                 if(pCnt[WhiteWazir+side])
6781                         return (pCnt[BlackKnight-side] + pCnt[BlackWazir-side] + pCnt[BlackAlfil-side]); // KWKN, KWKW, KWKE
6782         }
6783
6784         return TRUE;
6785 }
6786
6787 int
6788 Adjudicate(ChessProgramState *cps)
6789 {       // [HGM] some adjudications useful with buggy engines
6790         // [HGM] adjudicate: made into separate routine, which now can be called after every move
6791         //       In any case it determnes if the game is a claimable draw (filling in EP_STATUS).
6792         //       Actually ending the game is now based on the additional internal condition canAdjudicate.
6793         //       Only when the game is ended, and the opponent is a computer, this opponent gets the move relayed.
6794         int k, count = 0; static int bare = 1;
6795         ChessProgramState *engineOpponent = (gameMode == TwoMachinesPlay ? cps->other : (cps ? NULL : &first));
6796         Boolean canAdjudicate = !appData.icsActive;
6797
6798         // most tests only when we understand the game, i.e. legality-checking on
6799             if( appData.testLegality )
6800             {   /* [HGM] Some more adjudications for obstinate engines */
6801                 int nrW, nrB, bishopColor, staleW, staleB, nr[EmptySquare+1], i;
6802                 static int moveCount = 6;
6803                 ChessMove result;
6804                 char *reason = NULL;
6805
6806                 /* Count what is on board. */
6807                 Count(boards[forwardMostMove], nr, &nrW, &nrB, &staleW, &staleB, &bishopColor);
6808
6809                 /* Some material-based adjudications that have to be made before stalemate test */
6810                 if(gameInfo.variant == VariantAtomic && nr[WhiteKing] + nr[BlackKing] < 2) {
6811                     // [HGM] atomic: stm must have lost his King on previous move, as destroying own K is illegal
6812                      boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // make claimable as if stm is checkmated
6813                      if(canAdjudicate && appData.checkMates) {
6814                          if(engineOpponent)
6815                            SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
6816                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6817                          GameEnds( WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins,
6818                                                         "Xboard adjudication: King destroyed", GE_XBOARD );
6819                          return 1;
6820                      }
6821                 }
6822
6823                 /* Bare King in Shatranj (loses) or Losers (wins) */
6824                 if( nrW == 1 || nrB == 1) {
6825                   if( gameInfo.variant == VariantLosers) { // [HGM] losers: bare King wins (stm must have it first)
6826                      boards[forwardMostMove][EP_STATUS] = EP_WINS;  // mark as win, so it becomes claimable
6827                      if(canAdjudicate && appData.checkMates) {
6828                          if(engineOpponent)
6829                            SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets to see move
6830                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6831                          GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
6832                                                         "Xboard adjudication: Bare king", GE_XBOARD );
6833                          return 1;
6834                      }
6835                   } else
6836                   if( gameInfo.variant == VariantShatranj && --bare < 0)
6837                   {    /* bare King */
6838                         boards[forwardMostMove][EP_STATUS] = EP_WINS; // make claimable as win for stm
6839                         if(canAdjudicate && appData.checkMates) {
6840                             /* but only adjudicate if adjudication enabled */
6841                             if(engineOpponent)
6842                               SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
6843                             ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6844                             GameEnds( nrW > 1 ? WhiteWins : nrB > 1 ? BlackWins : GameIsDrawn,
6845                                                         "Xboard adjudication: Bare king", GE_XBOARD );
6846                             return 1;
6847                         }
6848                   }
6849                 } else bare = 1;
6850
6851
6852             // don't wait for engine to announce game end if we can judge ourselves
6853             switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove)) ) {
6854               case MT_CHECK:
6855                 if(gameInfo.variant == Variant3Check) { // [HGM] 3check: when in check, test if 3rd time
6856                     int i, checkCnt = 0;    // (should really be done by making nr of checks part of game state)
6857                     for(i=forwardMostMove-2; i>=backwardMostMove; i-=2) {
6858                         if(MateTest(boards[i], PosFlags(i)) == MT_CHECK)
6859                             checkCnt++;
6860                         if(checkCnt >= 2) {
6861                             reason = "Xboard adjudication: 3rd check";
6862                             boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE;
6863                             break;
6864                         }
6865                     }
6866                 }
6867               case MT_NONE:
6868               default:
6869                 break;
6870               case MT_STALEMATE:
6871               case MT_STAINMATE:
6872                 reason = "Xboard adjudication: Stalemate";
6873                 if((signed char)boards[forwardMostMove][EP_STATUS] != EP_CHECKMATE) { // [HGM] don't touch win through baring or K-capt
6874                     boards[forwardMostMove][EP_STATUS] = EP_STALEMATE;   // default result for stalemate is draw
6875                     if(gameInfo.variant == VariantLosers  || gameInfo.variant == VariantGiveaway) // [HGM] losers:
6876                         boards[forwardMostMove][EP_STATUS] = EP_WINS;    // in these variants stalemated is always a win
6877                     else if(gameInfo.variant == VariantSuicide) // in suicide it depends
6878                         boards[forwardMostMove][EP_STATUS] = nrW == nrB ? EP_STALEMATE :
6879                                                    ((nrW < nrB) != WhiteOnMove(forwardMostMove) ?
6880                                                                         EP_CHECKMATE : EP_WINS);
6881                     else if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantXiangqi)
6882                         boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // and in these variants being stalemated loses
6883                 }
6884                 break;
6885               case MT_CHECKMATE:
6886                 reason = "Xboard adjudication: Checkmate";
6887                 boards[forwardMostMove][EP_STATUS] = (gameInfo.variant == VariantLosers ? EP_WINS : EP_CHECKMATE);
6888                 break;
6889             }
6890
6891                 switch(i = (signed char)boards[forwardMostMove][EP_STATUS]) {
6892                     case EP_STALEMATE:
6893                         result = GameIsDrawn; break;
6894                     case EP_CHECKMATE:
6895                         result = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins; break;
6896                     case EP_WINS:
6897                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins; break;
6898                     default:
6899                         result = EndOfFile;
6900                 }
6901                 if(canAdjudicate && appData.checkMates && result) { // [HGM] mates: adjudicate finished games if requested
6902                     if(engineOpponent)
6903                       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6904                     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6905                     GameEnds( result, reason, GE_XBOARD );
6906                     return 1;
6907                 }
6908
6909                 /* Next absolutely insufficient mating material. */
6910                 if(!MatingPotential(nr, WhitePawn, nrW, nrB, staleW, bishopColor) &&
6911                    !MatingPotential(nr, BlackPawn, nrB, nrW, staleB, bishopColor))
6912                 {    /* includes KBK, KNK, KK of KBKB with like Bishops */
6913
6914                      /* always flag draws, for judging claims */
6915                      boards[forwardMostMove][EP_STATUS] = EP_INSUF_DRAW;
6916
6917                      if(canAdjudicate && appData.materialDraws) {
6918                          /* but only adjudicate them if adjudication enabled */
6919                          if(engineOpponent) {
6920                            SendToProgram("force\n", engineOpponent); // suppress reply
6921                            SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see last move */
6922                          }
6923                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6924                          GameEnds( GameIsDrawn, "Xboard adjudication: Insufficient mating material", GE_XBOARD );
6925                          return 1;
6926                      }
6927                 }
6928
6929                 /* Then some trivial draws (only adjudicate, cannot be claimed) */
6930                 if(gameInfo.variant == VariantXiangqi ?
6931                        SufficientDefence(nr, WhitePawn, nrW, nrB) && SufficientDefence(nr, BlackPawn, nrB, nrW)
6932                  : nrW + nrB == 4 &&
6933                    (   nr[WhiteRook] == 1 && nr[BlackRook] == 1 /* KRKR */
6934                    || nr[WhiteQueen] && nr[BlackQueen]==1     /* KQKQ */
6935                    || nr[WhiteKnight]==2 || nr[BlackKnight]==2     /* KNNK */
6936                    || nr[WhiteKnight]+nr[WhiteBishop] == 1 && nr[BlackKnight]+nr[BlackBishop] == 1 /* KBKN, KBKB, KNKN */
6937                    ) ) {
6938                      if(--moveCount < 0 && appData.trivialDraws && canAdjudicate)
6939                      {    /* if the first 3 moves do not show a tactical win, declare draw */
6940                           if(engineOpponent) {
6941                             SendToProgram("force\n", engineOpponent); // suppress reply
6942                             SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6943                           }
6944                           ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6945                           GameEnds( GameIsDrawn, "Xboard adjudication: Trivial draw", GE_XBOARD );
6946                           return 1;
6947                      }
6948                 } else moveCount = 6;
6949             }
6950         if (appData.debugMode) { int i;
6951             fprintf(debugFP, "repeat test fmm=%d bmm=%d ep=%d, reps=%d\n",
6952                     forwardMostMove, backwardMostMove, boards[backwardMostMove][EP_STATUS],
6953                     appData.drawRepeats);
6954             for( i=forwardMostMove; i>=backwardMostMove; i-- )
6955               fprintf(debugFP, "%d ep=%d\n", i, (signed char)boards[i][EP_STATUS]);
6956
6957         }
6958
6959         // Repetition draws and 50-move rule can be applied independently of legality testing
6960
6961                 /* Check for rep-draws */
6962                 count = 0;
6963                 for(k = forwardMostMove-2;
6964                     k>=backwardMostMove && k>=forwardMostMove-100 &&
6965                         (signed char)boards[k][EP_STATUS] < EP_UNKNOWN &&
6966                         (signed char)boards[k+2][EP_STATUS] <= EP_NONE && (signed char)boards[k+1][EP_STATUS] <= EP_NONE;
6967                     k-=2)
6968                 {   int rights=0;
6969                     if(CompareBoards(boards[k], boards[forwardMostMove])) {
6970                         /* compare castling rights */
6971                         if( boards[forwardMostMove][CASTLING][2] != boards[k][CASTLING][2] &&
6972                              (boards[k][CASTLING][0] != NoRights || boards[k][CASTLING][1] != NoRights) )
6973                                 rights++; /* King lost rights, while rook still had them */
6974                         if( boards[forwardMostMove][CASTLING][2] != NoRights ) { /* king has rights */
6975                             if( boards[forwardMostMove][CASTLING][0] != boards[k][CASTLING][0] ||
6976                                 boards[forwardMostMove][CASTLING][1] != boards[k][CASTLING][1] )
6977                                    rights++; /* but at least one rook lost them */
6978                         }
6979                         if( boards[forwardMostMove][CASTLING][5] != boards[k][CASTLING][5] &&
6980                              (boards[k][CASTLING][3] != NoRights || boards[k][CASTLING][4] != NoRights) )
6981                                 rights++;
6982                         if( boards[forwardMostMove][CASTLING][5] != NoRights ) {
6983                             if( boards[forwardMostMove][CASTLING][3] != boards[k][CASTLING][3] ||
6984                                 boards[forwardMostMove][CASTLING][4] != boards[k][CASTLING][4] )
6985                                    rights++;
6986                         }
6987                         if( rights == 0 && ++count > appData.drawRepeats-2 && canAdjudicate
6988                             && appData.drawRepeats > 1) {
6989                              /* adjudicate after user-specified nr of repeats */
6990                              int result = GameIsDrawn;
6991                              char *details = "XBoard adjudication: repetition draw";
6992                              if(gameInfo.variant == VariantXiangqi && appData.testLegality) {
6993                                 // [HGM] xiangqi: check for forbidden perpetuals
6994                                 int m, ourPerpetual = 1, hisPerpetual = 1;
6995                                 for(m=forwardMostMove; m>k; m-=2) {
6996                                     if(MateTest(boards[m], PosFlags(m)) != MT_CHECK)
6997                                         ourPerpetual = 0; // the current mover did not always check
6998                                     if(MateTest(boards[m-1], PosFlags(m-1)) != MT_CHECK)
6999                                         hisPerpetual = 0; // the opponent did not always check
7000                                 }
7001                                 if(appData.debugMode) fprintf(debugFP, "XQ perpetual test, our=%d, his=%d\n",
7002                                                                         ourPerpetual, hisPerpetual);
7003                                 if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit
7004                                     result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
7005                                     details = "Xboard adjudication: perpetual checking";
7006                                 } else
7007                                 if(hisPerpetual && !ourPerpetual) { // he is checking us, but did not repeat yet
7008                                     break; // (or we would have caught him before). Abort repetition-checking loop.
7009                                 } else
7010                                 // Now check for perpetual chases
7011                                 if(!ourPerpetual && !hisPerpetual) { // no perpetual check, test for chase
7012                                     hisPerpetual = PerpetualChase(k, forwardMostMove);
7013                                     ourPerpetual = PerpetualChase(k+1, forwardMostMove);
7014                                     if(ourPerpetual && !hisPerpetual) { // we are actively chasing him: forfeit
7015                                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
7016                                         details = "Xboard adjudication: perpetual chasing";
7017                                     } else
7018                                     if(hisPerpetual && !ourPerpetual)   // he is chasing us, but did not repeat yet
7019                                         break; // Abort repetition-checking loop.
7020                                 }
7021                                 // if neither of us is checking or chasing all the time, or both are, it is draw
7022                              }
7023                              if(engineOpponent) {
7024                                SendToProgram("force\n", engineOpponent); // suppress reply
7025                                SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
7026                              }
7027                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7028                              GameEnds( result, details, GE_XBOARD );
7029                              return 1;
7030                         }
7031                         if( rights == 0 && count > 1 ) /* occurred 2 or more times before */
7032                              boards[forwardMostMove][EP_STATUS] = EP_REP_DRAW;
7033                     }
7034                 }
7035
7036                 /* Now we test for 50-move draws. Determine ply count */
7037                 count = forwardMostMove;
7038                 /* look for last irreversble move */
7039                 while( (signed char)boards[count][EP_STATUS] <= EP_NONE && count > backwardMostMove )
7040                     count--;
7041                 /* if we hit starting position, add initial plies */
7042                 if( count == backwardMostMove )
7043                     count -= initialRulePlies;
7044                 count = forwardMostMove - count;
7045                 if(gameInfo.variant == VariantXiangqi && ( count >= 100 || count >= 2*appData.ruleMoves ) ) {
7046                         // adjust reversible move counter for checks in Xiangqi
7047                         int i = forwardMostMove - count, inCheck = 0, lastCheck;
7048                         if(i < backwardMostMove) i = backwardMostMove;
7049                         while(i <= forwardMostMove) {
7050                                 lastCheck = inCheck; // check evasion does not count
7051                                 inCheck = (MateTest(boards[i], PosFlags(i)) == MT_CHECK);
7052                                 if(inCheck || lastCheck) count--; // check does not count
7053                                 i++;
7054                         }
7055                 }
7056                 if( count >= 100)
7057                          boards[forwardMostMove][EP_STATUS] = EP_RULE_DRAW;
7058                          /* this is used to judge if draw claims are legal */
7059                 if(canAdjudicate && appData.ruleMoves > 0 && count >= 2*appData.ruleMoves) {
7060                          if(engineOpponent) {
7061                            SendToProgram("force\n", engineOpponent); // suppress reply
7062                            SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
7063                          }
7064                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7065                          GameEnds( GameIsDrawn, "Xboard adjudication: 50-move rule", GE_XBOARD );
7066                          return 1;
7067                 }
7068
7069                 /* if draw offer is pending, treat it as a draw claim
7070                  * when draw condition present, to allow engines a way to
7071                  * claim draws before making their move to avoid a race
7072                  * condition occurring after their move
7073                  */
7074                 if((gameMode == TwoMachinesPlay ? second.offeredDraw : userOfferedDraw) || first.offeredDraw ) {
7075                          char *p = NULL;
7076                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_RULE_DRAW)
7077                              p = "Draw claim: 50-move rule";
7078                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_REP_DRAW)
7079                              p = "Draw claim: 3-fold repetition";
7080                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_INSUF_DRAW)
7081                              p = "Draw claim: insufficient mating material";
7082                          if( p != NULL && canAdjudicate) {
7083                              if(engineOpponent) {
7084                                SendToProgram("force\n", engineOpponent); // suppress reply
7085                                SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
7086                              }
7087                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7088                              GameEnds( GameIsDrawn, p, GE_XBOARD );
7089                              return 1;
7090                          }
7091                 }
7092
7093                 if( canAdjudicate && appData.adjudicateDrawMoves > 0 && forwardMostMove > (2*appData.adjudicateDrawMoves) ) {
7094                     if(engineOpponent) {
7095                       SendToProgram("force\n", engineOpponent); // suppress reply
7096                       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
7097                     }
7098                     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7099                     GameEnds( GameIsDrawn, "Xboard adjudication: long game", GE_XBOARD );
7100                     return 1;
7101                 }
7102         return 0;
7103 }
7104
7105 char *SendMoveToBookUser(int moveNr, ChessProgramState *cps, int initial)
7106 {   // [HGM] book: this routine intercepts moves to simulate book replies
7107     char *bookHit = NULL;
7108
7109     //first determine if the incoming move brings opponent into his book
7110     if(appData.usePolyglotBook && (cps == &first ? !appData.firstHasOwnBookUCI : !appData.secondHasOwnBookUCI))
7111         bookHit = ProbeBook(moveNr+1, appData.polyglotBook); // returns move
7112     if(appData.debugMode) fprintf(debugFP, "book hit = %s\n", bookHit ? bookHit : "(NULL)");
7113     if(bookHit != NULL && !cps->bookSuspend) {
7114         // make sure opponent is not going to reply after receiving move to book position
7115         SendToProgram("force\n", cps);
7116         cps->bookSuspend = TRUE; // flag indicating it has to be restarted
7117     }
7118     if(!initial) SendMoveToProgram(moveNr, cps); // with hit on initial position there is no move
7119     // now arrange restart after book miss
7120     if(bookHit) {
7121         // after a book hit we never send 'go', and the code after the call to this routine
7122         // has '&& !bookHit' added to suppress potential sending there (based on 'firstMove').
7123         char buf[MSG_SIZ];
7124         snprintf(buf, MSG_SIZ, "%s%s\n", (cps->useUsermove ? "usermove " : ""), bookHit); // force book move into program supposed to play it
7125         SendToProgram(buf, cps);
7126         if(!initial) firstMove = FALSE; // normally we would clear the firstMove condition after return & sending 'go'
7127     } else if(initial) { // 'go' was needed irrespective of firstMove, and it has to be done in this routine
7128         SendToProgram("go\n", cps);
7129         cps->bookSuspend = FALSE; // after a 'go' we are never suspended
7130     } else { // 'go' might be sent based on 'firstMove' after this routine returns
7131         if(cps->bookSuspend && !firstMove) // 'go' needed, and it will not be done after we return
7132             SendToProgram("go\n", cps);
7133         cps->bookSuspend = FALSE; // anyhow, we will not be suspended after a miss
7134     }
7135     return bookHit; // notify caller of hit, so it can take action to send move to opponent
7136 }
7137
7138 char *savedMessage;
7139 ChessProgramState *savedState;
7140 void DeferredBookMove(void)
7141 {
7142         if(savedState->lastPing != savedState->lastPong)
7143                     ScheduleDelayedEvent(DeferredBookMove, 10);
7144         else
7145         HandleMachineMove(savedMessage, savedState);
7146 }
7147
7148 void
7149 HandleMachineMove(message, cps)
7150      char *message;
7151      ChessProgramState *cps;
7152 {
7153     char machineMove[MSG_SIZ], buf1[MSG_SIZ*10], buf2[MSG_SIZ];
7154     char realname[MSG_SIZ];
7155     int fromX, fromY, toX, toY;
7156     ChessMove moveType;
7157     char promoChar;
7158     char *p;
7159     int machineWhite;
7160     char *bookHit;
7161
7162     cps->userError = 0;
7163
7164 FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book hit
7165     /*
7166      * Kludge to ignore BEL characters
7167      */
7168     while (*message == '\007') message++;
7169
7170     /*
7171      * [HGM] engine debug message: ignore lines starting with '#' character
7172      */
7173     if(cps->debug && *message == '#') return;
7174
7175     /*
7176      * Look for book output
7177      */
7178     if (cps == &first && bookRequested) {
7179         if (message[0] == '\t' || message[0] == ' ') {
7180             /* Part of the book output is here; append it */
7181             strcat(bookOutput, message);
7182             strcat(bookOutput, "  \n");
7183             return;
7184         } else if (bookOutput[0] != NULLCHAR) {
7185             /* All of book output has arrived; display it */
7186             char *p = bookOutput;
7187             while (*p != NULLCHAR) {
7188                 if (*p == '\t') *p = ' ';
7189                 p++;
7190             }
7191             DisplayInformation(bookOutput);
7192             bookRequested = FALSE;
7193             /* Fall through to parse the current output */
7194         }
7195     }
7196
7197     /*
7198      * Look for machine move.
7199      */
7200     if ((sscanf(message, "%s %s %s", buf1, buf2, machineMove) == 3 && strcmp(buf2, "...") == 0) ||
7201         (sscanf(message, "%s %s", buf1, machineMove) == 2 && strcmp(buf1, "move") == 0))
7202     {
7203         /* This method is only useful on engines that support ping */
7204         if (cps->lastPing != cps->lastPong) {
7205           if (gameMode == BeginningOfGame) {
7206             /* Extra move from before last new; ignore */
7207             if (appData.debugMode) {
7208                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
7209             }
7210           } else {
7211             if (appData.debugMode) {
7212                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
7213                         cps->which, gameMode);
7214             }
7215
7216             SendToProgram("undo\n", cps);
7217           }
7218           return;
7219         }
7220
7221         switch (gameMode) {
7222           case BeginningOfGame:
7223             /* Extra move from before last reset; ignore */
7224             if (appData.debugMode) {
7225                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
7226             }
7227             return;
7228
7229           case EndOfGame:
7230           case IcsIdle:
7231           default:
7232             /* Extra move after we tried to stop.  The mode test is
7233                not a reliable way of detecting this problem, but it's
7234                the best we can do on engines that don't support ping.
7235             */
7236             if (appData.debugMode) {
7237                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
7238                         cps->which, gameMode);
7239             }
7240             SendToProgram("undo\n", cps);
7241             return;
7242
7243           case MachinePlaysWhite:
7244           case IcsPlayingWhite:
7245             machineWhite = TRUE;
7246             break;
7247
7248           case MachinePlaysBlack:
7249           case IcsPlayingBlack:
7250             machineWhite = FALSE;
7251             break;
7252
7253           case TwoMachinesPlay:
7254             machineWhite = (cps->twoMachinesColor[0] == 'w');
7255             break;
7256         }
7257         if (WhiteOnMove(forwardMostMove) != machineWhite) {
7258             if (appData.debugMode) {
7259                 fprintf(debugFP,
7260                         "Ignoring move out of turn by %s, gameMode %d"
7261                         ", forwardMost %d\n",
7262                         cps->which, gameMode, forwardMostMove);
7263             }
7264             return;
7265         }
7266
7267     if (appData.debugMode) { int f = forwardMostMove;
7268         fprintf(debugFP, "machine move %d, castling = %d %d %d %d %d %d\n", f,
7269                 boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
7270                 boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
7271     }
7272         if(cps->alphaRank) AlphaRank(machineMove, 4);
7273         if (!ParseOneMove(machineMove, forwardMostMove, &moveType,
7274                               &fromX, &fromY, &toX, &toY, &promoChar)) {
7275             /* Machine move could not be parsed; ignore it. */
7276           snprintf(buf1, MSG_SIZ*10, _("Illegal move \"%s\" from %s machine"),
7277                     machineMove, cps->which);
7278             DisplayError(buf1, 0);
7279             snprintf(buf1, MSG_SIZ*10, "Xboard: Forfeit due to invalid move: %s (%c%c%c%c) res=%d",
7280                     machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, moveType);
7281             if (gameMode == TwoMachinesPlay) {
7282               GameEnds(machineWhite ? BlackWins : WhiteWins,
7283                        buf1, GE_XBOARD);
7284             }
7285             return;
7286         }
7287
7288         /* [HGM] Apparently legal, but so far only tested with EP_UNKOWN */
7289         /* So we have to redo legality test with true e.p. status here,  */
7290         /* to make sure an illegal e.p. capture does not slip through,   */
7291         /* to cause a forfeit on a justified illegal-move complaint      */
7292         /* of the opponent.                                              */
7293         if( gameMode==TwoMachinesPlay && appData.testLegality ) {
7294            ChessMove moveType;
7295            moveType = LegalityTest(boards[forwardMostMove], PosFlags(forwardMostMove),
7296                              fromY, fromX, toY, toX, promoChar);
7297             if (appData.debugMode) {
7298                 int i;
7299                 for(i=0; i< nrCastlingRights; i++) fprintf(debugFP, "(%d,%d) ",
7300                     boards[forwardMostMove][CASTLING][i], castlingRank[i]);
7301                 fprintf(debugFP, "castling rights\n");
7302             }
7303             if(moveType == IllegalMove) {
7304               snprintf(buf1, MSG_SIZ*10, "Xboard: Forfeit due to illegal move: %s (%c%c%c%c)%c",
7305                         machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, 0);
7306                 GameEnds(machineWhite ? BlackWins : WhiteWins,
7307                            buf1, GE_XBOARD);
7308                 return;
7309            } else if(gameInfo.variant != VariantFischeRandom && gameInfo.variant != VariantCapaRandom)
7310            /* [HGM] Kludge to handle engines that send FRC-style castling
7311               when they shouldn't (like TSCP-Gothic) */
7312            switch(moveType) {
7313              case WhiteASideCastleFR:
7314              case BlackASideCastleFR:
7315                toX+=2;
7316                currentMoveString[2]++;
7317                break;
7318              case WhiteHSideCastleFR:
7319              case BlackHSideCastleFR:
7320                toX--;
7321                currentMoveString[2]--;
7322                break;
7323              default: ; // nothing to do, but suppresses warning of pedantic compilers
7324            }
7325         }
7326         hintRequested = FALSE;
7327         lastHint[0] = NULLCHAR;
7328         bookRequested = FALSE;
7329         /* Program may be pondering now */
7330         cps->maybeThinking = TRUE;
7331         if (cps->sendTime == 2) cps->sendTime = 1;
7332         if (cps->offeredDraw) cps->offeredDraw--;
7333
7334         /* currentMoveString is set as a side-effect of ParseOneMove */
7335         safeStrCpy(machineMove, currentMoveString, sizeof(machineMove)/sizeof(machineMove[0]));
7336         strcat(machineMove, "\n");
7337         safeStrCpy(moveList[forwardMostMove], machineMove, sizeof(moveList[forwardMostMove])/sizeof(moveList[forwardMostMove][0]));
7338
7339         /* [AS] Save move info*/
7340         pvInfoList[ forwardMostMove ].score = programStats.score;
7341         pvInfoList[ forwardMostMove ].depth = programStats.depth;
7342         pvInfoList[ forwardMostMove ].time =  programStats.time; // [HGM] PGNtime: take time from engine stats
7343
7344         MakeMove(fromX, fromY, toX, toY, promoChar);/*updates forwardMostMove*/
7345
7346         /* [AS] Adjudicate game if needed (note: remember that forwardMostMove now points past the last move) */
7347         if( gameMode == TwoMachinesPlay && adjudicateLossThreshold != 0 && forwardMostMove >= adjudicateLossPlies ) {
7348             int count = 0;
7349
7350             while( count < adjudicateLossPlies ) {
7351                 int score = pvInfoList[ forwardMostMove - count - 1 ].score;
7352
7353                 if( count & 1 ) {
7354                     score = -score; /* Flip score for winning side */
7355                 }
7356
7357                 if( score > adjudicateLossThreshold ) {
7358                     break;
7359                 }
7360
7361                 count++;
7362             }
7363
7364             if( count >= adjudicateLossPlies ) {
7365                 ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7366
7367                 GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
7368                     "Xboard adjudication",
7369                     GE_XBOARD );
7370
7371                 return;
7372             }
7373         }
7374
7375         if(Adjudicate(cps)) return; // [HGM] adjudicate: for all automatic game ends
7376
7377 #if ZIPPY
7378         if ((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack) &&
7379             first.initDone) {
7380           if(cps->offeredDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
7381                 SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
7382                 SendToICS("draw ");
7383                 SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
7384           }
7385           SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
7386           ics_user_moved = 1;
7387           if(appData.autoKibitz && !appData.icsEngineAnalyze ) { /* [HGM] kibitz: send most-recent PV info to ICS */
7388                 char buf[3*MSG_SIZ];
7389
7390                 snprintf(buf, 3*MSG_SIZ, "kibitz !!! %+.2f/%d (%.2f sec, %u nodes, %.0f knps) PV=%s\n",
7391                         programStats.score / 100.,
7392                         programStats.depth,
7393                         programStats.time / 100.,
7394                         (unsigned int)programStats.nodes,
7395                         (unsigned int)programStats.nodes / (10*abs(programStats.time) + 1.),
7396                         programStats.movelist);
7397                 SendToICS(buf);
7398 if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.nodes, programStats.nodes);
7399           }
7400         }
7401 #endif
7402
7403         /* [AS] Clear stats for next move */
7404         ClearProgramStats();
7405         thinkOutput[0] = NULLCHAR;
7406         hiddenThinkOutputState = 0;
7407
7408         bookHit = NULL;
7409         if (gameMode == TwoMachinesPlay) {
7410             /* [HGM] relaying draw offers moved to after reception of move */
7411             /* and interpreting offer as claim if it brings draw condition */
7412             if (cps->offeredDraw == 1 && cps->other->sendDrawOffers) {
7413                 SendToProgram("draw\n", cps->other);
7414             }
7415             if (cps->other->sendTime) {
7416                 SendTimeRemaining(cps->other,
7417                                   cps->other->twoMachinesColor[0] == 'w');
7418             }
7419             bookHit = SendMoveToBookUser(forwardMostMove-1, cps->other, FALSE);
7420             if (firstMove && !bookHit) {
7421                 firstMove = FALSE;
7422                 if (cps->other->useColors) {
7423                   SendToProgram(cps->other->twoMachinesColor, cps->other);
7424                 }
7425                 SendToProgram("go\n", cps->other);
7426             }
7427             cps->other->maybeThinking = TRUE;
7428         }
7429
7430         ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7431
7432         if (!pausing && appData.ringBellAfterMoves) {
7433             RingBell();
7434         }
7435
7436         /*
7437          * Reenable menu items that were disabled while
7438          * machine was thinking
7439          */
7440         if (gameMode != TwoMachinesPlay)
7441             SetUserThinkingEnables();
7442
7443         // [HGM] book: after book hit opponent has received move and is now in force mode
7444         // force the book reply into it, and then fake that it outputted this move by jumping
7445         // back to the beginning of HandleMachineMove, with cps toggled and message set to this move
7446         if(bookHit) {
7447                 static char bookMove[MSG_SIZ]; // a bit generous?
7448
7449                 safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
7450                 strcat(bookMove, bookHit);
7451                 message = bookMove;
7452                 cps = cps->other;
7453                 programStats.nodes = programStats.depth = programStats.time =
7454                 programStats.score = programStats.got_only_move = 0;
7455                 sprintf(programStats.movelist, "%s (xbook)", bookHit);
7456
7457                 if(cps->lastPing != cps->lastPong) {
7458                     savedMessage = message; // args for deferred call
7459                     savedState = cps;
7460                     ScheduleDelayedEvent(DeferredBookMove, 10);
7461                     return;
7462                 }
7463                 goto FakeBookMove;
7464         }
7465
7466         return;
7467     }
7468
7469     /* Set special modes for chess engines.  Later something general
7470      *  could be added here; for now there is just one kludge feature,
7471      *  needed because Crafty 15.10 and earlier don't ignore SIGINT
7472      *  when "xboard" is given as an interactive command.
7473      */
7474     if (strncmp(message, "kibitz Hello from Crafty", 24) == 0) {
7475         cps->useSigint = FALSE;
7476         cps->useSigterm = FALSE;
7477     }
7478     if (strncmp(message, "feature ", 8) == 0) { // [HGM] moved forward to pre-empt non-compliant commands
7479       ParseFeatures(message+8, cps);
7480       return; // [HGM] This return was missing, causing option features to be recognized as non-compliant commands!
7481     }
7482
7483     if (!appData.testLegality && !strncmp(message, "setup ", 6)) { // [HGM] allow first engine to define opening position
7484       int dummy, s=6; char buf[MSG_SIZ];
7485       if(appData.icsActive || forwardMostMove != 0 || cps != &first || startedFromSetupPosition) return;
7486       if(sscanf(message, "setup (%s", buf) == 1) s = 8 + strlen(buf), buf[s-9] = NULLCHAR, SetCharTable(pieceToChar, buf);
7487       ParseFEN(boards[0], &dummy, message+s);
7488       DrawPosition(TRUE, boards[0]);
7489       startedFromSetupPosition = TRUE;
7490       return;
7491     }
7492     /* [HGM] Allow engine to set up a position. Don't ask me why one would
7493      * want this, I was asked to put it in, and obliged.
7494      */
7495     if (!strncmp(message, "setboard ", 9)) {
7496         Board initial_position;
7497
7498         GameEnds(GameUnfinished, "Engine aborts game", GE_XBOARD);
7499
7500         if (!ParseFEN(initial_position, &blackPlaysFirst, message + 9)) {
7501             DisplayError(_("Bad FEN received from engine"), 0);
7502             return ;
7503         } else {
7504            Reset(TRUE, FALSE);
7505            CopyBoard(boards[0], initial_position);
7506            initialRulePlies = FENrulePlies;
7507            if(blackPlaysFirst) gameMode = MachinePlaysWhite;
7508            else gameMode = MachinePlaysBlack;
7509            DrawPosition(FALSE, boards[currentMove]);
7510         }
7511         return;
7512     }
7513
7514     /*
7515      * Look for communication commands
7516      */
7517     if (!strncmp(message, "telluser ", 9)) {
7518         if(message[9] == '\\' && message[10] == '\\')
7519             EscapeExpand(message+9, message+11); // [HGM] esc: allow escape sequences in popup box
7520         DisplayNote(message + 9);
7521         return;
7522     }
7523     if (!strncmp(message, "tellusererror ", 14)) {
7524         cps->userError = 1;
7525         if(message[14] == '\\' && message[15] == '\\')
7526             EscapeExpand(message+14, message+16); // [HGM] esc: allow escape sequences in popup box
7527         DisplayError(message + 14, 0);
7528         return;
7529     }
7530     if (!strncmp(message, "tellopponent ", 13)) {
7531       if (appData.icsActive) {
7532         if (loggedOn) {
7533           snprintf(buf1, sizeof(buf1), "%ssay %s\n", ics_prefix, message + 13);
7534           SendToICS(buf1);
7535         }
7536       } else {
7537         DisplayNote(message + 13);
7538       }
7539       return;
7540     }
7541     if (!strncmp(message, "tellothers ", 11)) {
7542       if (appData.icsActive) {
7543         if (loggedOn) {
7544           snprintf(buf1, sizeof(buf1), "%swhisper %s\n", ics_prefix, message + 11);
7545           SendToICS(buf1);
7546         }
7547       }
7548       return;
7549     }
7550     if (!strncmp(message, "tellall ", 8)) {
7551       if (appData.icsActive) {
7552         if (loggedOn) {
7553           snprintf(buf1, sizeof(buf1), "%skibitz %s\n", ics_prefix, message + 8);
7554           SendToICS(buf1);
7555         }
7556       } else {
7557         DisplayNote(message + 8);
7558       }
7559       return;
7560     }
7561     if (strncmp(message, "warning", 7) == 0) {
7562         /* Undocumented feature, use tellusererror in new code */
7563         DisplayError(message, 0);
7564         return;
7565     }
7566     if (sscanf(message, "askuser %s %[^\n]", buf1, buf2) == 2) {
7567         safeStrCpy(realname, cps->tidy, sizeof(realname)/sizeof(realname[0]));
7568         strcat(realname, " query");
7569         AskQuestion(realname, buf2, buf1, cps->pr);
7570         return;
7571     }
7572     /* Commands from the engine directly to ICS.  We don't allow these to be
7573      *  sent until we are logged on. Crafty kibitzes have been known to
7574      *  interfere with the login process.
7575      */
7576     if (loggedOn) {
7577         if (!strncmp(message, "tellics ", 8)) {
7578             SendToICS(message + 8);
7579             SendToICS("\n");
7580             return;
7581         }
7582         if (!strncmp(message, "tellicsnoalias ", 15)) {
7583             SendToICS(ics_prefix);
7584             SendToICS(message + 15);
7585             SendToICS("\n");
7586             return;
7587         }
7588         /* The following are for backward compatibility only */
7589         if (!strncmp(message,"whisper",7) || !strncmp(message,"kibitz",6) ||
7590             !strncmp(message,"draw",4) || !strncmp(message,"tell",3)) {
7591             SendToICS(ics_prefix);
7592             SendToICS(message);
7593             SendToICS("\n");
7594             return;
7595         }
7596     }
7597     if (sscanf(message, "pong %d", &cps->lastPong) == 1) {
7598         return;
7599     }
7600     /*
7601      * If the move is illegal, cancel it and redraw the board.
7602      * Also deal with other error cases.  Matching is rather loose
7603      * here to accommodate engines written before the spec.
7604      */
7605     if (strncmp(message + 1, "llegal move", 11) == 0 ||
7606         strncmp(message, "Error", 5) == 0) {
7607         if (StrStr(message, "name") ||
7608             StrStr(message, "rating") || StrStr(message, "?") ||
7609             StrStr(message, "result") || StrStr(message, "board") ||
7610             StrStr(message, "bk") || StrStr(message, "computer") ||
7611             StrStr(message, "variant") || StrStr(message, "hint") ||
7612             StrStr(message, "random") || StrStr(message, "depth") ||
7613             StrStr(message, "accepted")) {
7614             return;
7615         }
7616         if (StrStr(message, "protover")) {
7617           /* Program is responding to input, so it's apparently done
7618              initializing, and this error message indicates it is
7619              protocol version 1.  So we don't need to wait any longer
7620              for it to initialize and send feature commands. */
7621           FeatureDone(cps, 1);
7622           cps->protocolVersion = 1;
7623           return;
7624         }
7625         cps->maybeThinking = FALSE;
7626
7627         if (StrStr(message, "draw")) {
7628             /* Program doesn't have "draw" command */
7629             cps->sendDrawOffers = 0;
7630             return;
7631         }
7632         if (cps->sendTime != 1 &&
7633             (StrStr(message, "time") || StrStr(message, "otim"))) {
7634           /* Program apparently doesn't have "time" or "otim" command */
7635           cps->sendTime = 0;
7636           return;
7637         }
7638         if (StrStr(message, "analyze")) {
7639             cps->analysisSupport = FALSE;
7640             cps->analyzing = FALSE;
7641             Reset(FALSE, TRUE);
7642             snprintf(buf2,MSG_SIZ, _("%s does not support analysis"), cps->tidy);
7643             DisplayError(buf2, 0);
7644             return;
7645         }
7646         if (StrStr(message, "(no matching move)st")) {
7647           /* Special kludge for GNU Chess 4 only */
7648           cps->stKludge = TRUE;
7649           SendTimeControl(cps, movesPerSession, timeControl,
7650                           timeIncrement, appData.searchDepth,
7651                           searchTime);
7652           return;
7653         }
7654         if (StrStr(message, "(no matching move)sd")) {
7655           /* Special kludge for GNU Chess 4 only */
7656           cps->sdKludge = TRUE;
7657           SendTimeControl(cps, movesPerSession, timeControl,
7658                           timeIncrement, appData.searchDepth,
7659                           searchTime);
7660           return;
7661         }
7662         if (!StrStr(message, "llegal")) {
7663             return;
7664         }
7665         if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
7666             gameMode == IcsIdle) return;
7667         if (forwardMostMove <= backwardMostMove) return;
7668         if (pausing) PauseEvent();
7669       if(appData.forceIllegal) {
7670             // [HGM] illegal: machine refused move; force position after move into it
7671           SendToProgram("force\n", cps);
7672           if(!cps->useSetboard) { // hideous kludge on kludge, because SendBoard sucks.
7673                 // we have a real problem now, as SendBoard will use the a2a3 kludge
7674                 // when black is to move, while there might be nothing on a2 or black
7675                 // might already have the move. So send the board as if white has the move.
7676                 // But first we must change the stm of the engine, as it refused the last move
7677                 SendBoard(cps, 0); // always kludgeless, as white is to move on boards[0]
7678                 if(WhiteOnMove(forwardMostMove)) {
7679                     SendToProgram("a7a6\n", cps); // for the engine black still had the move
7680                     SendBoard(cps, forwardMostMove); // kludgeless board
7681                 } else {
7682                     SendToProgram("a2a3\n", cps); // for the engine white still had the move
7683                     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
7684                     SendBoard(cps, forwardMostMove+1); // kludgeless board
7685                 }
7686           } else SendBoard(cps, forwardMostMove); // FEN case, also sets stm properly
7687             if(gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
7688                  gameMode == TwoMachinesPlay)
7689               SendToProgram("go\n", cps);
7690             return;
7691       } else
7692         if (gameMode == PlayFromGameFile) {
7693             /* Stop reading this game file */
7694             gameMode = EditGame;
7695             ModeHighlight();
7696         }
7697         currentMove = forwardMostMove-1;
7698         DisplayMove(currentMove-1); /* before DisplayMoveError */
7699         SwitchClocks(forwardMostMove-1); // [HGM] race
7700         DisplayBothClocks();
7701         snprintf(buf1, 10*MSG_SIZ, _("Illegal move \"%s\" (rejected by %s chess program)"),
7702                 parseList[currentMove], cps->which);
7703         DisplayMoveError(buf1);
7704         DrawPosition(FALSE, boards[currentMove]);
7705
7706         /* [HGM] illegal-move claim should forfeit game when Xboard */
7707         /* only passes fully legal moves                            */
7708         if( appData.testLegality && gameMode == TwoMachinesPlay ) {
7709             GameEnds( cps->twoMachinesColor[0] == 'w' ? BlackWins : WhiteWins,
7710                                 "False illegal-move claim", GE_XBOARD );
7711         }
7712         return;
7713     }
7714     if (strncmp(message, "time", 4) == 0 && StrStr(message, "Illegal")) {
7715         /* Program has a broken "time" command that
7716            outputs a string not ending in newline.
7717            Don't use it. */
7718         cps->sendTime = 0;
7719     }
7720
7721     /*
7722      * If chess program startup fails, exit with an error message.
7723      * Attempts to recover here are futile.
7724      */
7725     if ((StrStr(message, "unknown host") != NULL)
7726         || (StrStr(message, "No remote directory") != NULL)
7727         || (StrStr(message, "not found") != NULL)
7728         || (StrStr(message, "No such file") != NULL)
7729         || (StrStr(message, "can't alloc") != NULL)
7730         || (StrStr(message, "Permission denied") != NULL)) {
7731
7732         cps->maybeThinking = FALSE;
7733         snprintf(buf1, sizeof(buf1), _("Failed to start %s chess program %s on %s: %s\n"),
7734                 cps->which, cps->program, cps->host, message);
7735         RemoveInputSource(cps->isr);
7736         DisplayFatalError(buf1, 0, 1);
7737         return;
7738     }
7739
7740     /*
7741      * Look for hint output
7742      */
7743     if (sscanf(message, "Hint: %s", buf1) == 1) {
7744         if (cps == &first && hintRequested) {
7745             hintRequested = FALSE;
7746             if (ParseOneMove(buf1, forwardMostMove, &moveType,
7747                                  &fromX, &fromY, &toX, &toY, &promoChar)) {
7748                 (void) CoordsToAlgebraic(boards[forwardMostMove],
7749                                     PosFlags(forwardMostMove),
7750                                     fromY, fromX, toY, toX, promoChar, buf1);
7751                 snprintf(buf2, sizeof(buf2), _("Hint: %s"), buf1);
7752                 DisplayInformation(buf2);
7753             } else {
7754                 /* Hint move could not be parsed!? */
7755               snprintf(buf2, sizeof(buf2),
7756                         _("Illegal hint move \"%s\"\nfrom %s chess program"),
7757                         buf1, cps->which);
7758                 DisplayError(buf2, 0);
7759             }
7760         } else {
7761           safeStrCpy(lastHint, buf1, sizeof(lastHint)/sizeof(lastHint[0]));
7762         }
7763         return;
7764     }
7765
7766     /*
7767      * Ignore other messages if game is not in progress
7768      */
7769     if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
7770         gameMode == IcsIdle || cps->lastPing != cps->lastPong) return;
7771
7772     /*
7773      * look for win, lose, draw, or draw offer
7774      */
7775     if (strncmp(message, "1-0", 3) == 0) {
7776         char *p, *q, *r = "";
7777         p = strchr(message, '{');
7778         if (p) {
7779             q = strchr(p, '}');
7780             if (q) {
7781                 *q = NULLCHAR;
7782                 r = p + 1;
7783             }
7784         }
7785         GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first)); /* [HGM] pass claimer indication for claim test */
7786         return;
7787     } else if (strncmp(message, "0-1", 3) == 0) {
7788         char *p, *q, *r = "";
7789         p = strchr(message, '{');
7790         if (p) {
7791             q = strchr(p, '}');
7792             if (q) {
7793                 *q = NULLCHAR;
7794                 r = p + 1;
7795             }
7796         }
7797         /* Kludge for Arasan 4.1 bug */
7798         if (strcmp(r, "Black resigns") == 0) {
7799             GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first));
7800             return;
7801         }
7802         GameEnds(BlackWins, r, GE_ENGINE1 + (cps != &first));
7803         return;
7804     } else if (strncmp(message, "1/2", 3) == 0) {
7805         char *p, *q, *r = "";
7806         p = strchr(message, '{');
7807         if (p) {
7808             q = strchr(p, '}');
7809             if (q) {
7810                 *q = NULLCHAR;
7811                 r = p + 1;
7812             }
7813         }
7814
7815         GameEnds(GameIsDrawn, r, GE_ENGINE1 + (cps != &first));
7816         return;
7817
7818     } else if (strncmp(message, "White resign", 12) == 0) {
7819         GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
7820         return;
7821     } else if (strncmp(message, "Black resign", 12) == 0) {
7822         GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
7823         return;
7824     } else if (strncmp(message, "White matches", 13) == 0 ||
7825                strncmp(message, "Black matches", 13) == 0   ) {
7826         /* [HGM] ignore GNUShogi noises */
7827         return;
7828     } else if (strncmp(message, "White", 5) == 0 &&
7829                message[5] != '(' &&
7830                StrStr(message, "Black") == NULL) {
7831         GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7832         return;
7833     } else if (strncmp(message, "Black", 5) == 0 &&
7834                message[5] != '(') {
7835         GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7836         return;
7837     } else if (strcmp(message, "resign") == 0 ||
7838                strcmp(message, "computer resigns") == 0) {
7839         switch (gameMode) {
7840           case MachinePlaysBlack:
7841           case IcsPlayingBlack:
7842             GameEnds(WhiteWins, "Black resigns", GE_ENGINE);
7843             break;
7844           case MachinePlaysWhite:
7845           case IcsPlayingWhite:
7846             GameEnds(BlackWins, "White resigns", GE_ENGINE);
7847             break;
7848           case TwoMachinesPlay:
7849             if (cps->twoMachinesColor[0] == 'w')
7850               GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
7851             else
7852               GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
7853             break;
7854           default:
7855             /* can't happen */
7856             break;
7857         }
7858         return;
7859     } else if (strncmp(message, "opponent mates", 14) == 0) {
7860         switch (gameMode) {
7861           case MachinePlaysBlack:
7862           case IcsPlayingBlack:
7863             GameEnds(WhiteWins, "White mates", GE_ENGINE);
7864             break;
7865           case MachinePlaysWhite:
7866           case IcsPlayingWhite:
7867             GameEnds(BlackWins, "Black mates", GE_ENGINE);
7868             break;
7869           case TwoMachinesPlay:
7870             if (cps->twoMachinesColor[0] == 'w')
7871               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7872             else
7873               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7874             break;
7875           default:
7876             /* can't happen */
7877             break;
7878         }
7879         return;
7880     } else if (strncmp(message, "computer mates", 14) == 0) {
7881         switch (gameMode) {
7882           case MachinePlaysBlack:
7883           case IcsPlayingBlack:
7884             GameEnds(BlackWins, "Black mates", GE_ENGINE1);
7885             break;
7886           case MachinePlaysWhite:
7887           case IcsPlayingWhite:
7888             GameEnds(WhiteWins, "White mates", GE_ENGINE);
7889             break;
7890           case TwoMachinesPlay:
7891             if (cps->twoMachinesColor[0] == 'w')
7892               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7893             else
7894               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7895             break;
7896           default:
7897             /* can't happen */
7898             break;
7899         }
7900         return;
7901     } else if (strncmp(message, "checkmate", 9) == 0) {
7902         if (WhiteOnMove(forwardMostMove)) {
7903             GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7904         } else {
7905             GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7906         }
7907         return;
7908     } else if (strstr(message, "Draw") != NULL ||
7909                strstr(message, "game is a draw") != NULL) {
7910         GameEnds(GameIsDrawn, "Draw", GE_ENGINE1 + (cps != &first));
7911         return;
7912     } else if (strstr(message, "offer") != NULL &&
7913                strstr(message, "draw") != NULL) {
7914 #if ZIPPY
7915         if (appData.zippyPlay && first.initDone) {
7916             /* Relay offer to ICS */
7917             SendToICS(ics_prefix);
7918             SendToICS("draw\n");
7919         }
7920 #endif
7921         cps->offeredDraw = 2; /* valid until this engine moves twice */
7922         if (gameMode == TwoMachinesPlay) {
7923             if (cps->other->offeredDraw) {
7924                 GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
7925             /* [HGM] in two-machine mode we delay relaying draw offer      */
7926             /* until after we also have move, to see if it is really claim */
7927             }
7928         } else if (gameMode == MachinePlaysWhite ||
7929                    gameMode == MachinePlaysBlack) {
7930           if (userOfferedDraw) {
7931             DisplayInformation(_("Machine accepts your draw offer"));
7932             GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
7933           } else {
7934             DisplayInformation(_("Machine offers a draw\nSelect Action / Draw to agree"));
7935           }
7936         }
7937     }
7938
7939
7940     /*
7941      * Look for thinking output
7942      */
7943     if ( appData.showThinking // [HGM] thinking: test all options that cause this output
7944           || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
7945                                 ) {
7946         int plylev, mvleft, mvtot, curscore, time;
7947         char mvname[MOVE_LEN];
7948         u64 nodes; // [DM]
7949         char plyext;
7950         int ignore = FALSE;
7951         int prefixHint = FALSE;
7952         mvname[0] = NULLCHAR;
7953
7954         switch (gameMode) {
7955           case MachinePlaysBlack:
7956           case IcsPlayingBlack:
7957             if (WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
7958             break;
7959           case MachinePlaysWhite:
7960           case IcsPlayingWhite:
7961             if (!WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
7962             break;
7963           case AnalyzeMode:
7964           case AnalyzeFile:
7965             break;
7966           case IcsObserving: /* [DM] icsEngineAnalyze */
7967             if (!appData.icsEngineAnalyze) ignore = TRUE;
7968             break;
7969           case TwoMachinesPlay:
7970             if ((cps->twoMachinesColor[0] == 'w') != WhiteOnMove(forwardMostMove)) {
7971                 ignore = TRUE;
7972             }
7973             break;
7974           default:
7975             ignore = TRUE;
7976             break;
7977         }
7978
7979         if (!ignore) {
7980             ChessProgramStats tempStats = programStats; // [HGM] info: filter out info lines
7981             buf1[0] = NULLCHAR;
7982             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
7983                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5) {
7984
7985                 if (plyext != ' ' && plyext != '\t') {
7986                     time *= 100;
7987                 }
7988
7989                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
7990                 if( cps->scoreIsAbsolute &&
7991                     ( gameMode == MachinePlaysBlack ||
7992                       gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b' ||
7993                       gameMode == IcsPlayingBlack ||     // [HGM] also add other situations where engine should report black POV
7994                      (gameMode == AnalyzeMode || gameMode == AnalyzeFile || gameMode == IcsObserving && appData.icsEngineAnalyze) &&
7995                      !WhiteOnMove(currentMove)
7996                     ) )
7997                 {
7998                     curscore = -curscore;
7999                 }
8000
8001
8002                 tempStats.depth = plylev;
8003                 tempStats.nodes = nodes;
8004                 tempStats.time = time;
8005                 tempStats.score = curscore;
8006                 tempStats.got_only_move = 0;
8007
8008                 if(cps->nps >= 0) { /* [HGM] nps: use engine nodes or time to decrement clock */
8009                         int ticklen;
8010
8011                         if(cps->nps == 0) ticklen = 10*time;                    // use engine reported time
8012                         else ticklen = (1000. * u64ToDouble(nodes)) / cps->nps; // convert node count to time
8013                         if(WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysWhite ||
8014                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'w'))
8015                              whiteTimeRemaining = timeRemaining[0][forwardMostMove] - ticklen;
8016                         if(!WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysBlack ||
8017                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b'))
8018                              blackTimeRemaining = timeRemaining[1][forwardMostMove] - ticklen;
8019                 }
8020
8021                 /* Buffer overflow protection */
8022                 if (buf1[0] != NULLCHAR) {
8023                     if (strlen(buf1) >= sizeof(tempStats.movelist)
8024                         && appData.debugMode) {
8025                         fprintf(debugFP,
8026                                 "PV is too long; using the first %u bytes.\n",
8027                                 (unsigned) sizeof(tempStats.movelist) - 1);
8028                     }
8029
8030                     safeStrCpy( tempStats.movelist, buf1, sizeof(tempStats.movelist)/sizeof(tempStats.movelist[0]) );
8031                 } else {
8032                     sprintf(tempStats.movelist, " no PV\n");
8033                 }
8034
8035                 if (tempStats.seen_stat) {
8036                     tempStats.ok_to_send = 1;
8037                 }
8038
8039                 if (strchr(tempStats.movelist, '(') != NULL) {
8040                     tempStats.line_is_book = 1;
8041                     tempStats.nr_moves = 0;
8042                     tempStats.moves_left = 0;
8043                 } else {
8044                     tempStats.line_is_book = 0;
8045                 }
8046
8047                     if(tempStats.score != 0 || tempStats.nodes != 0 || tempStats.time != 0)
8048                         programStats = tempStats; // [HGM] info: only set stats if genuine PV and not an info line
8049
8050                 SendProgramStatsToFrontend( cps, &tempStats );
8051
8052                 /*
8053                     [AS] Protect the thinkOutput buffer from overflow... this
8054                     is only useful if buf1 hasn't overflowed first!
8055                 */
8056                 snprintf(thinkOutput, sizeof(thinkOutput)/sizeof(thinkOutput[0]), "[%d]%c%+.2f %s%s",
8057                          plylev,
8058                          (gameMode == TwoMachinesPlay ?
8059                           ToUpper(cps->twoMachinesColor[0]) : ' '),
8060                          ((double) curscore) / 100.0,
8061                          prefixHint ? lastHint : "",
8062                          prefixHint ? " " : "" );
8063
8064                 if( buf1[0] != NULLCHAR ) {
8065                     unsigned max_len = sizeof(thinkOutput) - strlen(thinkOutput) - 1;
8066
8067                     if( strlen(buf1) > max_len ) {
8068                         if( appData.debugMode) {
8069                             fprintf(debugFP,"PV is too long for thinkOutput, truncating.\n");
8070                         }
8071                         buf1[max_len+1] = '\0';
8072                     }
8073
8074                     strcat( thinkOutput, buf1 );
8075                 }
8076
8077                 if (currentMove == forwardMostMove || gameMode == AnalyzeMode
8078                         || gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
8079                     DisplayMove(currentMove - 1);
8080                 }
8081                 return;
8082
8083             } else if ((p=StrStr(message, "(only move)")) != NULL) {
8084                 /* crafty (9.25+) says "(only move) <move>"
8085                  * if there is only 1 legal move
8086                  */
8087                 sscanf(p, "(only move) %s", buf1);
8088                 snprintf(thinkOutput, sizeof(thinkOutput)/sizeof(thinkOutput[0]), "%s (only move)", buf1);
8089                 sprintf(programStats.movelist, "%s (only move)", buf1);
8090                 programStats.depth = 1;
8091                 programStats.nr_moves = 1;
8092                 programStats.moves_left = 1;
8093                 programStats.nodes = 1;
8094                 programStats.time = 1;
8095                 programStats.got_only_move = 1;
8096
8097                 /* Not really, but we also use this member to
8098                    mean "line isn't going to change" (Crafty
8099                    isn't searching, so stats won't change) */
8100                 programStats.line_is_book = 1;
8101
8102                 SendProgramStatsToFrontend( cps, &programStats );
8103
8104                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
8105                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
8106                     DisplayMove(currentMove - 1);
8107                 }
8108                 return;
8109             } else if (sscanf(message,"stat01: %d " u64Display " %d %d %d %s",
8110                               &time, &nodes, &plylev, &mvleft,
8111                               &mvtot, mvname) >= 5) {
8112                 /* The stat01: line is from Crafty (9.29+) in response
8113                    to the "." command */
8114                 programStats.seen_stat = 1;
8115                 cps->maybeThinking = TRUE;
8116
8117                 if (programStats.got_only_move || !appData.periodicUpdates)
8118                   return;
8119
8120                 programStats.depth = plylev;
8121                 programStats.time = time;
8122                 programStats.nodes = nodes;
8123                 programStats.moves_left = mvleft;
8124                 programStats.nr_moves = mvtot;
8125                 safeStrCpy(programStats.move_name, mvname, sizeof(programStats.move_name)/sizeof(programStats.move_name[0]));
8126                 programStats.ok_to_send = 1;
8127                 programStats.movelist[0] = '\0';
8128
8129                 SendProgramStatsToFrontend( cps, &programStats );
8130
8131                 return;
8132
8133             } else if (strncmp(message,"++",2) == 0) {
8134                 /* Crafty 9.29+ outputs this */
8135                 programStats.got_fail = 2;
8136                 return;
8137
8138             } else if (strncmp(message,"--",2) == 0) {
8139                 /* Crafty 9.29+ outputs this */
8140                 programStats.got_fail = 1;
8141                 return;
8142
8143             } else if (thinkOutput[0] != NULLCHAR &&
8144                        strncmp(message, "    ", 4) == 0) {
8145                 unsigned message_len;
8146
8147                 p = message;
8148                 while (*p && *p == ' ') p++;
8149
8150                 message_len = strlen( p );
8151
8152                 /* [AS] Avoid buffer overflow */
8153                 if( sizeof(thinkOutput) - strlen(thinkOutput) - 1 > message_len ) {
8154                     strcat(thinkOutput, " ");
8155                     strcat(thinkOutput, p);
8156                 }
8157
8158                 if( sizeof(programStats.movelist) - strlen(programStats.movelist) - 1 > message_len ) {
8159                     strcat(programStats.movelist, " ");
8160                     strcat(programStats.movelist, p);
8161                 }
8162
8163                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
8164                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
8165                     DisplayMove(currentMove - 1);
8166                 }
8167                 return;
8168             }
8169         }
8170         else {
8171             buf1[0] = NULLCHAR;
8172
8173             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
8174                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5)
8175             {
8176                 ChessProgramStats cpstats;
8177
8178                 if (plyext != ' ' && plyext != '\t') {
8179                     time *= 100;
8180                 }
8181
8182                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
8183                 if( cps->scoreIsAbsolute && ((gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b')) ) {
8184                     curscore = -curscore;
8185                 }
8186
8187                 cpstats.depth = plylev;
8188                 cpstats.nodes = nodes;
8189                 cpstats.time = time;
8190                 cpstats.score = curscore;
8191                 cpstats.got_only_move = 0;
8192                 cpstats.movelist[0] = '\0';
8193
8194                 if (buf1[0] != NULLCHAR) {
8195                     safeStrCpy( cpstats.movelist, buf1, sizeof(cpstats.movelist)/sizeof(cpstats.movelist[0]) );
8196                 }
8197
8198                 cpstats.ok_to_send = 0;
8199                 cpstats.line_is_book = 0;
8200                 cpstats.nr_moves = 0;
8201                 cpstats.moves_left = 0;
8202
8203                 SendProgramStatsToFrontend( cps, &cpstats );
8204             }
8205         }
8206     }
8207 }
8208
8209
8210 /* Parse a game score from the character string "game", and
8211    record it as the history of the current game.  The game
8212    score is NOT assumed to start from the standard position.
8213    The display is not updated in any way.
8214    */
8215 void
8216 ParseGameHistory(game)
8217      char *game;
8218 {
8219     ChessMove moveType;
8220     int fromX, fromY, toX, toY, boardIndex;
8221     char promoChar;
8222     char *p, *q;
8223     char buf[MSG_SIZ];
8224
8225     if (appData.debugMode)
8226       fprintf(debugFP, "Parsing game history: %s\n", game);
8227
8228     if (gameInfo.event == NULL) gameInfo.event = StrSave("ICS game");
8229     gameInfo.site = StrSave(appData.icsHost);
8230     gameInfo.date = PGNDate();
8231     gameInfo.round = StrSave("-");
8232
8233     /* Parse out names of players */
8234     while (*game == ' ') game++;
8235     p = buf;
8236     while (*game != ' ') *p++ = *game++;
8237     *p = NULLCHAR;
8238     gameInfo.white = StrSave(buf);
8239     while (*game == ' ') game++;
8240     p = buf;
8241     while (*game != ' ' && *game != '\n') *p++ = *game++;
8242     *p = NULLCHAR;
8243     gameInfo.black = StrSave(buf);
8244
8245     /* Parse moves */
8246     boardIndex = blackPlaysFirst ? 1 : 0;
8247     yynewstr(game);
8248     for (;;) {
8249         yyboardindex = boardIndex;
8250         moveType = (ChessMove) Myylex();
8251         switch (moveType) {
8252           case IllegalMove:             /* maybe suicide chess, etc. */
8253   if (appData.debugMode) {
8254     fprintf(debugFP, "Illegal move from ICS: '%s'\n", yy_text);
8255     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
8256     setbuf(debugFP, NULL);
8257   }
8258           case WhitePromotion:
8259           case BlackPromotion:
8260           case WhiteNonPromotion:
8261           case BlackNonPromotion:
8262           case NormalMove:
8263           case WhiteCapturesEnPassant:
8264           case BlackCapturesEnPassant:
8265           case WhiteKingSideCastle:
8266           case WhiteQueenSideCastle:
8267           case BlackKingSideCastle:
8268           case BlackQueenSideCastle:
8269           case WhiteKingSideCastleWild:
8270           case WhiteQueenSideCastleWild:
8271           case BlackKingSideCastleWild:
8272           case BlackQueenSideCastleWild:
8273           /* PUSH Fabien */
8274           case WhiteHSideCastleFR:
8275           case WhiteASideCastleFR:
8276           case BlackHSideCastleFR:
8277           case BlackASideCastleFR:
8278           /* POP Fabien */
8279             fromX = currentMoveString[0] - AAA;
8280             fromY = currentMoveString[1] - ONE;
8281             toX = currentMoveString[2] - AAA;
8282             toY = currentMoveString[3] - ONE;
8283             promoChar = currentMoveString[4];
8284             break;
8285           case WhiteDrop:
8286           case BlackDrop:
8287             fromX = moveType == WhiteDrop ?
8288               (int) CharToPiece(ToUpper(currentMoveString[0])) :
8289             (int) CharToPiece(ToLower(currentMoveString[0]));
8290             fromY = DROP_RANK;
8291             toX = currentMoveString[2] - AAA;
8292             toY = currentMoveString[3] - ONE;
8293             promoChar = NULLCHAR;
8294             break;
8295           case AmbiguousMove:
8296             /* bug? */
8297             snprintf(buf, MSG_SIZ, _("Ambiguous move in ICS output: \"%s\""), yy_text);
8298   if (appData.debugMode) {
8299     fprintf(debugFP, "Ambiguous move from ICS: '%s'\n", yy_text);
8300     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
8301     setbuf(debugFP, NULL);
8302   }
8303             DisplayError(buf, 0);
8304             return;
8305           case ImpossibleMove:
8306             /* bug? */
8307             snprintf(buf, MSG_SIZ, _("Illegal move in ICS output: \"%s\""), yy_text);
8308   if (appData.debugMode) {
8309     fprintf(debugFP, "Impossible move from ICS: '%s'\n", yy_text);
8310     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
8311     setbuf(debugFP, NULL);
8312   }
8313             DisplayError(buf, 0);
8314             return;
8315           case EndOfFile:
8316             if (boardIndex < backwardMostMove) {
8317                 /* Oops, gap.  How did that happen? */
8318                 DisplayError(_("Gap in move list"), 0);
8319                 return;
8320             }
8321             backwardMostMove =  blackPlaysFirst ? 1 : 0;
8322             if (boardIndex > forwardMostMove) {
8323                 forwardMostMove = boardIndex;
8324             }
8325             return;
8326           case ElapsedTime:
8327             if (boardIndex > (blackPlaysFirst ? 1 : 0)) {
8328                 strcat(parseList[boardIndex-1], " ");
8329                 strcat(parseList[boardIndex-1], yy_text);
8330             }
8331             continue;
8332           case Comment:
8333           case PGNTag:
8334           case NAG:
8335           default:
8336             /* ignore */
8337             continue;
8338           case WhiteWins:
8339           case BlackWins:
8340           case GameIsDrawn:
8341           case GameUnfinished:
8342             if (gameMode == IcsExamining) {
8343                 if (boardIndex < backwardMostMove) {
8344                     /* Oops, gap.  How did that happen? */
8345                     return;
8346                 }
8347                 backwardMostMove = blackPlaysFirst ? 1 : 0;
8348                 return;
8349             }
8350             gameInfo.result = moveType;
8351             p = strchr(yy_text, '{');
8352             if (p == NULL) p = strchr(yy_text, '(');
8353             if (p == NULL) {
8354                 p = yy_text;
8355                 if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
8356             } else {
8357                 q = strchr(p, *p == '{' ? '}' : ')');
8358                 if (q != NULL) *q = NULLCHAR;
8359                 p++;
8360             }
8361             gameInfo.resultDetails = StrSave(p);
8362             continue;
8363         }
8364         if (boardIndex >= forwardMostMove &&
8365             !(gameMode == IcsObserving && ics_gamenum == -1)) {
8366             backwardMostMove = blackPlaysFirst ? 1 : 0;
8367             return;
8368         }
8369         (void) CoordsToAlgebraic(boards[boardIndex], PosFlags(boardIndex),
8370                                  fromY, fromX, toY, toX, promoChar,
8371                                  parseList[boardIndex]);
8372         CopyBoard(boards[boardIndex + 1], boards[boardIndex]);
8373         /* currentMoveString is set as a side-effect of yylex */
8374         safeStrCpy(moveList[boardIndex], currentMoveString, sizeof(moveList[boardIndex])/sizeof(moveList[boardIndex][0]));
8375         strcat(moveList[boardIndex], "\n");
8376         boardIndex++;
8377         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[boardIndex]);
8378         switch (MateTest(boards[boardIndex], PosFlags(boardIndex)) ) {
8379           case MT_NONE:
8380           case MT_STALEMATE:
8381           default:
8382             break;
8383           case MT_CHECK:
8384             if(gameInfo.variant != VariantShogi)
8385                 strcat(parseList[boardIndex - 1], "+");
8386             break;
8387           case MT_CHECKMATE:
8388           case MT_STAINMATE:
8389             strcat(parseList[boardIndex - 1], "#");
8390             break;
8391         }
8392     }
8393 }
8394
8395
8396 /* Apply a move to the given board  */
8397 void
8398 ApplyMove(fromX, fromY, toX, toY, promoChar, board)
8399      int fromX, fromY, toX, toY;
8400      int promoChar;
8401      Board board;
8402 {
8403   ChessSquare captured = board[toY][toX], piece, king; int p, oldEP = EP_NONE, berolina = 0;
8404   int promoRank = gameInfo.variant == VariantMakruk ? 3 : 1;
8405
8406     /* [HGM] compute & store e.p. status and castling rights for new position */
8407     /* we can always do that 'in place', now pointers to these rights are passed to ApplyMove */
8408
8409       if(gameInfo.variant == VariantBerolina) berolina = EP_BEROLIN_A;
8410       oldEP = (signed char)board[EP_STATUS];
8411       board[EP_STATUS] = EP_NONE;
8412
8413       if( board[toY][toX] != EmptySquare )
8414            board[EP_STATUS] = EP_CAPTURE;
8415
8416   if (fromY == DROP_RANK) {
8417         /* must be first */
8418         piece = board[toY][toX] = (ChessSquare) fromX;
8419   } else {
8420       int i;
8421
8422       if( board[fromY][fromX] == WhitePawn ) {
8423            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
8424                board[EP_STATUS] = EP_PAWN_MOVE;
8425            if( toY-fromY==2) {
8426                if(toX>BOARD_LEFT   && board[toY][toX-1] == BlackPawn &&
8427                         gameInfo.variant != VariantBerolina || toX < fromX)
8428                       board[EP_STATUS] = toX | berolina;
8429                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == BlackPawn &&
8430                         gameInfo.variant != VariantBerolina || toX > fromX)
8431                       board[EP_STATUS] = toX;
8432            }
8433       } else
8434       if( board[fromY][fromX] == BlackPawn ) {
8435            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
8436                board[EP_STATUS] = EP_PAWN_MOVE;
8437            if( toY-fromY== -2) {
8438                if(toX>BOARD_LEFT   && board[toY][toX-1] == WhitePawn &&
8439                         gameInfo.variant != VariantBerolina || toX < fromX)
8440                       board[EP_STATUS] = toX | berolina;
8441                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == WhitePawn &&
8442                         gameInfo.variant != VariantBerolina || toX > fromX)
8443                       board[EP_STATUS] = toX;
8444            }
8445        }
8446
8447        for(i=0; i<nrCastlingRights; i++) {
8448            if(board[CASTLING][i] == fromX && castlingRank[i] == fromY ||
8449               board[CASTLING][i] == toX   && castlingRank[i] == toY
8450              ) board[CASTLING][i] = NoRights; // revoke for moved or captured piece
8451        }
8452
8453      if (fromX == toX && fromY == toY) return;
8454
8455      piece = board[fromY][fromX]; /* [HGM] remember, for Shogi promotion */
8456      king = piece < (int) BlackPawn ? WhiteKing : BlackKing; /* [HGM] Knightmate simplify testing for castling */
8457      if(gameInfo.variant == VariantKnightmate)
8458          king += (int) WhiteUnicorn - (int) WhiteKing;
8459
8460     /* Code added by Tord: */
8461     /* FRC castling assumed when king captures friendly rook. [HGM] or RxK for S-Chess */
8462     if (board[fromY][fromX] == WhiteKing && board[toY][toX] == WhiteRook ||
8463         board[fromY][fromX] == WhiteRook && board[toY][toX] == WhiteKing) {
8464       board[fromY][fromX] = EmptySquare;
8465       board[toY][toX] = EmptySquare;
8466       if((toX > fromX) != (piece == WhiteRook)) {
8467         board[0][BOARD_RGHT-2] = WhiteKing; board[0][BOARD_RGHT-3] = WhiteRook;
8468       } else {
8469         board[0][BOARD_LEFT+2] = WhiteKing; board[0][BOARD_LEFT+3] = WhiteRook;
8470       }
8471     } else if (board[fromY][fromX] == BlackKing && board[toY][toX] == BlackRook ||
8472                board[fromY][fromX] == BlackRook && board[toY][toX] == BlackKing) {
8473       board[fromY][fromX] = EmptySquare;
8474       board[toY][toX] = EmptySquare;
8475       if((toX > fromX) != (piece == BlackRook)) {
8476         board[BOARD_HEIGHT-1][BOARD_RGHT-2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_RGHT-3] = BlackRook;
8477       } else {
8478         board[BOARD_HEIGHT-1][BOARD_LEFT+2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_LEFT+3] = BlackRook;
8479       }
8480     /* End of code added by Tord */
8481
8482     } else if (board[fromY][fromX] == king
8483         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8484         && toY == fromY && toX > fromX+1) {
8485         board[fromY][fromX] = EmptySquare;
8486         board[toY][toX] = king;
8487         board[toY][toX-1] = board[fromY][BOARD_RGHT-1];
8488         board[fromY][BOARD_RGHT-1] = EmptySquare;
8489     } else if (board[fromY][fromX] == king
8490         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8491                && toY == fromY && toX < fromX-1) {
8492         board[fromY][fromX] = EmptySquare;
8493         board[toY][toX] = king;
8494         board[toY][toX+1] = board[fromY][BOARD_LEFT];
8495         board[fromY][BOARD_LEFT] = EmptySquare;
8496     } else if (board[fromY][fromX] == WhitePawn
8497                && toY >= BOARD_HEIGHT-promoRank
8498                && gameInfo.variant != VariantXiangqi
8499                ) {
8500         /* white pawn promotion */
8501         board[toY][toX] = CharToPiece(ToUpper(promoChar));
8502         if (board[toY][toX] == EmptySquare) {
8503             board[toY][toX] = WhiteQueen;
8504         }
8505         if(gameInfo.variant==VariantBughouse ||
8506            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
8507             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
8508         board[fromY][fromX] = EmptySquare;
8509     } else if ((fromY == BOARD_HEIGHT-4)
8510                && (toX != fromX)
8511                && gameInfo.variant != VariantXiangqi
8512                && gameInfo.variant != VariantBerolina
8513                && (board[fromY][fromX] == WhitePawn)
8514                && (board[toY][toX] == EmptySquare)) {
8515         board[fromY][fromX] = EmptySquare;
8516         board[toY][toX] = WhitePawn;
8517         captured = board[toY - 1][toX];
8518         board[toY - 1][toX] = EmptySquare;
8519     } else if ((fromY == BOARD_HEIGHT-4)
8520                && (toX == fromX)
8521                && gameInfo.variant == VariantBerolina
8522                && (board[fromY][fromX] == WhitePawn)
8523                && (board[toY][toX] == EmptySquare)) {
8524         board[fromY][fromX] = EmptySquare;
8525         board[toY][toX] = WhitePawn;
8526         if(oldEP & EP_BEROLIN_A) {
8527                 captured = board[fromY][fromX-1];
8528                 board[fromY][fromX-1] = EmptySquare;
8529         }else{  captured = board[fromY][fromX+1];
8530                 board[fromY][fromX+1] = EmptySquare;
8531         }
8532     } else if (board[fromY][fromX] == king
8533         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8534                && toY == fromY && toX > fromX+1) {
8535         board[fromY][fromX] = EmptySquare;
8536         board[toY][toX] = king;
8537         board[toY][toX-1] = board[fromY][BOARD_RGHT-1];
8538         board[fromY][BOARD_RGHT-1] = EmptySquare;
8539     } else if (board[fromY][fromX] == king
8540         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8541                && toY == fromY && toX < fromX-1) {
8542         board[fromY][fromX] = EmptySquare;
8543         board[toY][toX] = king;
8544         board[toY][toX+1] = board[fromY][BOARD_LEFT];
8545         board[fromY][BOARD_LEFT] = EmptySquare;
8546     } else if (fromY == 7 && fromX == 3
8547                && board[fromY][fromX] == BlackKing
8548                && toY == 7 && toX == 5) {
8549         board[fromY][fromX] = EmptySquare;
8550         board[toY][toX] = BlackKing;
8551         board[fromY][7] = EmptySquare;
8552         board[toY][4] = BlackRook;
8553     } else if (fromY == 7 && fromX == 3
8554                && board[fromY][fromX] == BlackKing
8555                && toY == 7 && toX == 1) {
8556         board[fromY][fromX] = EmptySquare;
8557         board[toY][toX] = BlackKing;
8558         board[fromY][0] = EmptySquare;
8559         board[toY][2] = BlackRook;
8560     } else if (board[fromY][fromX] == BlackPawn
8561                && toY < promoRank
8562                && gameInfo.variant != VariantXiangqi
8563                ) {
8564         /* black pawn promotion */
8565         board[toY][toX] = CharToPiece(ToLower(promoChar));
8566         if (board[toY][toX] == EmptySquare) {
8567             board[toY][toX] = BlackQueen;
8568         }
8569         if(gameInfo.variant==VariantBughouse ||
8570            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
8571             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
8572         board[fromY][fromX] = EmptySquare;
8573     } else if ((fromY == 3)
8574                && (toX != fromX)
8575                && gameInfo.variant != VariantXiangqi
8576                && gameInfo.variant != VariantBerolina
8577                && (board[fromY][fromX] == BlackPawn)
8578                && (board[toY][toX] == EmptySquare)) {
8579         board[fromY][fromX] = EmptySquare;
8580         board[toY][toX] = BlackPawn;
8581         captured = board[toY + 1][toX];
8582         board[toY + 1][toX] = EmptySquare;
8583     } else if ((fromY == 3)
8584                && (toX == fromX)
8585                && gameInfo.variant == VariantBerolina
8586                && (board[fromY][fromX] == BlackPawn)
8587                && (board[toY][toX] == EmptySquare)) {
8588         board[fromY][fromX] = EmptySquare;
8589         board[toY][toX] = BlackPawn;
8590         if(oldEP & EP_BEROLIN_A) {
8591                 captured = board[fromY][fromX-1];
8592                 board[fromY][fromX-1] = EmptySquare;
8593         }else{  captured = board[fromY][fromX+1];
8594                 board[fromY][fromX+1] = EmptySquare;
8595         }
8596     } else {
8597         board[toY][toX] = board[fromY][fromX];
8598         board[fromY][fromX] = EmptySquare;
8599     }
8600   }
8601
8602     if (gameInfo.holdingsWidth != 0) {
8603
8604       /* !!A lot more code needs to be written to support holdings  */
8605       /* [HGM] OK, so I have written it. Holdings are stored in the */
8606       /* penultimate board files, so they are automaticlly stored   */
8607       /* in the game history.                                       */
8608       if (fromY == DROP_RANK || gameInfo.variant == VariantSChess
8609                                 && promoChar && piece != WhitePawn && piece != BlackPawn) {
8610         /* Delete from holdings, by decreasing count */
8611         /* and erasing image if necessary            */
8612         p = fromY == DROP_RANK ? (int) fromX : CharToPiece(piece > BlackPawn ? ToLower(promoChar) : ToUpper(promoChar));
8613         if(p < (int) BlackPawn) { /* white drop */
8614              p -= (int)WhitePawn;
8615                  p = PieceToNumber((ChessSquare)p);
8616              if(p >= gameInfo.holdingsSize) p = 0;
8617              if(--board[p][BOARD_WIDTH-2] <= 0)
8618                   board[p][BOARD_WIDTH-1] = EmptySquare;
8619              if((int)board[p][BOARD_WIDTH-2] < 0)
8620                         board[p][BOARD_WIDTH-2] = 0;
8621         } else {                  /* black drop */
8622              p -= (int)BlackPawn;
8623                  p = PieceToNumber((ChessSquare)p);
8624              if(p >= gameInfo.holdingsSize) p = 0;
8625              if(--board[BOARD_HEIGHT-1-p][1] <= 0)
8626                   board[BOARD_HEIGHT-1-p][0] = EmptySquare;
8627              if((int)board[BOARD_HEIGHT-1-p][1] < 0)
8628                         board[BOARD_HEIGHT-1-p][1] = 0;
8629         }
8630       }
8631       if (captured != EmptySquare && gameInfo.holdingsSize > 0
8632           && gameInfo.variant != VariantBughouse && gameInfo.variant != VariantSChess        ) {
8633         /* [HGM] holdings: Add to holdings, if holdings exist */
8634         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
8635                 // [HGM] superchess: suppress flipping color of captured pieces by reverse pre-flip
8636                 captured = (int) captured >= (int) BlackPawn ? BLACK_TO_WHITE captured : WHITE_TO_BLACK captured;
8637         }
8638         p = (int) captured;
8639         if (p >= (int) BlackPawn) {
8640           p -= (int)BlackPawn;
8641           if(gameInfo.variant == VariantShogi && DEMOTED p >= 0) {
8642                   /* in Shogi restore piece to its original  first */
8643                   captured = (ChessSquare) (DEMOTED captured);
8644                   p = DEMOTED p;
8645           }
8646           p = PieceToNumber((ChessSquare)p);
8647           if(p >= gameInfo.holdingsSize) { p = 0; captured = BlackPawn; }
8648           board[p][BOARD_WIDTH-2]++;
8649           board[p][BOARD_WIDTH-1] = BLACK_TO_WHITE captured;
8650         } else {
8651           p -= (int)WhitePawn;
8652           if(gameInfo.variant == VariantShogi && DEMOTED p >= 0) {
8653                   captured = (ChessSquare) (DEMOTED captured);
8654                   p = DEMOTED p;
8655           }
8656           p = PieceToNumber((ChessSquare)p);
8657           if(p >= gameInfo.holdingsSize) { p = 0; captured = WhitePawn; }
8658           board[BOARD_HEIGHT-1-p][1]++;
8659           board[BOARD_HEIGHT-1-p][0] = WHITE_TO_BLACK captured;
8660         }
8661       }
8662     } else if (gameInfo.variant == VariantAtomic) {
8663       if (captured != EmptySquare) {
8664         int y, x;
8665         for (y = toY-1; y <= toY+1; y++) {
8666           for (x = toX-1; x <= toX+1; x++) {
8667             if (y >= 0 && y < BOARD_HEIGHT && x >= BOARD_LEFT && x < BOARD_RGHT &&
8668                 board[y][x] != WhitePawn && board[y][x] != BlackPawn) {
8669               board[y][x] = EmptySquare;
8670             }
8671           }
8672         }
8673         board[toY][toX] = EmptySquare;
8674       }
8675     }
8676     if(gameInfo.variant == VariantSChess && promoChar != NULLCHAR && promoChar != '=' && piece != WhitePawn && piece != BlackPawn) {
8677         board[fromY][fromX] = CharToPiece(piece < BlackPawn ? ToUpper(promoChar) : ToLower(promoChar)); // S-Chess gating
8678     } else
8679     if(promoChar == '+') {
8680         /* [HGM] Shogi-style promotions, to piece implied by original (Might overwrite orinary Pawn promotion) */
8681         board[toY][toX] = (ChessSquare) (PROMOTED piece);
8682     } else if(!appData.testLegality && promoChar != NULLCHAR && promoChar != '=') { // without legality testing, unconditionally believe promoChar
8683         board[toY][toX] = CharToPiece(piece < BlackPawn ? ToUpper(promoChar) : ToLower(promoChar));
8684     }
8685     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
8686                 && promoChar != NULLCHAR && gameInfo.holdingsSize) {
8687         // [HGM] superchess: take promotion piece out of holdings
8688         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
8689         if((int)piece < (int)BlackPawn) { // determine stm from piece color
8690             if(!--board[k][BOARD_WIDTH-2])
8691                 board[k][BOARD_WIDTH-1] = EmptySquare;
8692         } else {
8693             if(!--board[BOARD_HEIGHT-1-k][1])
8694                 board[BOARD_HEIGHT-1-k][0] = EmptySquare;
8695         }
8696     }
8697
8698 }
8699
8700 /* Updates forwardMostMove */
8701 void
8702 MakeMove(fromX, fromY, toX, toY, promoChar)
8703      int fromX, fromY, toX, toY;
8704      int promoChar;
8705 {
8706 //    forwardMostMove++; // [HGM] bare: moved downstream
8707
8708     if(serverMoves != NULL) { /* [HGM] write moves on file for broadcasting (should be separate routine, really) */
8709         int timeLeft; static int lastLoadFlag=0; int king, piece;
8710         piece = boards[forwardMostMove][fromY][fromX];
8711         king = piece < (int) BlackPawn ? WhiteKing : BlackKing;
8712         if(gameInfo.variant == VariantKnightmate)
8713             king += (int) WhiteUnicorn - (int) WhiteKing;
8714         if(forwardMostMove == 0) {
8715             if(blackPlaysFirst)
8716                 fprintf(serverMoves, "%s;", second.tidy);
8717             fprintf(serverMoves, "%s;", first.tidy);
8718             if(!blackPlaysFirst)
8719                 fprintf(serverMoves, "%s;", second.tidy);
8720         } else fprintf(serverMoves, loadFlag|lastLoadFlag ? ":" : ";");
8721         lastLoadFlag = loadFlag;
8722         // print base move
8723         fprintf(serverMoves, "%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+toY);
8724         // print castling suffix
8725         if( toY == fromY && piece == king ) {
8726             if(toX-fromX > 1)
8727                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_RGHT-1, ONE+fromY, AAA+toX-1,ONE+toY);
8728             if(fromX-toX >1)
8729                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_LEFT, ONE+fromY, AAA+toX+1,ONE+toY);
8730         }
8731         // e.p. suffix
8732         if( (boards[forwardMostMove][fromY][fromX] == WhitePawn ||
8733              boards[forwardMostMove][fromY][fromX] == BlackPawn   ) &&
8734              boards[forwardMostMove][toY][toX] == EmptySquare
8735              && fromX != toX && fromY != toY)
8736                 fprintf(serverMoves, ":%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+fromY);
8737         // promotion suffix
8738         if(promoChar != NULLCHAR)
8739                 fprintf(serverMoves, ":%c:%c%c", promoChar, AAA+toX, ONE+toY);
8740         if(!loadFlag) {
8741             fprintf(serverMoves, "/%d/%d",
8742                pvInfoList[forwardMostMove].depth, pvInfoList[forwardMostMove].score);
8743             if(forwardMostMove+1 & 1) timeLeft = whiteTimeRemaining/1000;
8744             else                      timeLeft = blackTimeRemaining/1000;
8745             fprintf(serverMoves, "/%d", timeLeft);
8746         }
8747         fflush(serverMoves);
8748     }
8749
8750     if (forwardMostMove+1 > framePtr) { // [HGM] vari: do not run into saved variations
8751       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
8752                         0, 1);
8753       return;
8754     }
8755     UnLoadPV(); // [HGM] pv: if we are looking at a PV, abort this
8756     if (commentList[forwardMostMove+1] != NULL) {
8757         free(commentList[forwardMostMove+1]);
8758         commentList[forwardMostMove+1] = NULL;
8759     }
8760     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
8761     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[forwardMostMove+1]);
8762     // forwardMostMove++; // [HGM] bare: moved to after ApplyMove, to make sure clock interrupt finds complete board
8763     SwitchClocks(forwardMostMove+1); // [HGM] race: incrementing move nr inside
8764     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
8765     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
8766     gameInfo.result = GameUnfinished;
8767     if (gameInfo.resultDetails != NULL) {
8768         free(gameInfo.resultDetails);
8769         gameInfo.resultDetails = NULL;
8770     }
8771     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar,
8772                               moveList[forwardMostMove - 1]);
8773     (void) CoordsToAlgebraic(boards[forwardMostMove - 1],
8774                              PosFlags(forwardMostMove - 1),
8775                              fromY, fromX, toY, toX, promoChar,
8776                              parseList[forwardMostMove - 1]);
8777     switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove)) ) {
8778       case MT_NONE:
8779       case MT_STALEMATE:
8780       default:
8781         break;
8782       case MT_CHECK:
8783         if(gameInfo.variant != VariantShogi)
8784             strcat(parseList[forwardMostMove - 1], "+");
8785         break;
8786       case MT_CHECKMATE:
8787       case MT_STAINMATE:
8788         strcat(parseList[forwardMostMove - 1], "#");
8789         break;
8790     }
8791     if (appData.debugMode) {
8792         fprintf(debugFP, "move: %s, parse: %s (%c)\n", moveList[forwardMostMove-1], parseList[forwardMostMove-1], moveList[forwardMostMove-1][4]);
8793     }
8794
8795 }
8796
8797 /* Updates currentMove if not pausing */
8798 void
8799 ShowMove(fromX, fromY, toX, toY)
8800 {
8801     int instant = (gameMode == PlayFromGameFile) ?
8802         (matchMode || (appData.timeDelay == 0 && !pausing)) : pausing;
8803     if(appData.noGUI) return;
8804     if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
8805         if (!instant) {
8806             if (forwardMostMove == currentMove + 1) {
8807                 AnimateMove(boards[forwardMostMove - 1],
8808                             fromX, fromY, toX, toY);
8809             }
8810             if (appData.highlightLastMove) {
8811                 SetHighlights(fromX, fromY, toX, toY);
8812             }
8813         }
8814         currentMove = forwardMostMove;
8815     }
8816
8817     if (instant) return;
8818
8819     DisplayMove(currentMove - 1);
8820     DrawPosition(FALSE, boards[currentMove]);
8821     DisplayBothClocks();
8822     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
8823 }
8824
8825 void SendEgtPath(ChessProgramState *cps)
8826 {       /* [HGM] EGT: match formats given in feature with those given by user, and send info for each match */
8827         char buf[MSG_SIZ], name[MSG_SIZ], *p;
8828
8829         if((p = cps->egtFormats) == NULL || appData.egtFormats == NULL) return;
8830
8831         while(*p) {
8832             char c, *q = name+1, *r, *s;
8833
8834             name[0] = ','; // extract next format name from feature and copy with prefixed ','
8835             while(*p && *p != ',') *q++ = *p++;
8836             *q++ = ':'; *q = 0;
8837             if( appData.defaultPathEGTB && appData.defaultPathEGTB[0] &&
8838                 strcmp(name, ",nalimov:") == 0 ) {
8839                 // take nalimov path from the menu-changeable option first, if it is defined
8840               snprintf(buf, MSG_SIZ, "egtpath nalimov %s\n", appData.defaultPathEGTB);
8841                 SendToProgram(buf,cps);     // send egtbpath command for nalimov
8842             } else
8843             if( (s = StrStr(appData.egtFormats, name+1)) == appData.egtFormats ||
8844                 (s = StrStr(appData.egtFormats, name)) != NULL) {
8845                 // format name occurs amongst user-supplied formats, at beginning or immediately after comma
8846                 s = r = StrStr(s, ":") + 1; // beginning of path info
8847                 while(*r && *r != ',') r++; // path info is everything upto next ';' or end of string
8848                 c = *r; *r = 0;             // temporarily null-terminate path info
8849                     *--q = 0;               // strip of trailig ':' from name
8850                     snprintf(buf, MSG_SIZ, "egtpath %s %s\n", name+1, s);
8851                 *r = c;
8852                 SendToProgram(buf,cps);     // send egtbpath command for this format
8853             }
8854             if(*p == ',') p++; // read away comma to position for next format name
8855         }
8856 }
8857
8858 void
8859 InitChessProgram(cps, setup)
8860      ChessProgramState *cps;
8861      int setup; /* [HGM] needed to setup FRC opening position */
8862 {
8863     char buf[MSG_SIZ], b[MSG_SIZ]; int overruled;
8864     if (appData.noChessProgram) return;
8865     hintRequested = FALSE;
8866     bookRequested = FALSE;
8867
8868     /* [HGM] some new WB protocol commands to configure engine are sent now, if engine supports them */
8869     /*       moved to before sending initstring in 4.3.15, so Polyglot can delay UCI 'isready' to recepton of 'new' */
8870     if(cps->memSize) { /* [HGM] memory */
8871       snprintf(buf, MSG_SIZ, "memory %d\n", appData.defaultHashSize + appData.defaultCacheSizeEGTB);
8872         SendToProgram(buf, cps);
8873     }
8874     SendEgtPath(cps); /* [HGM] EGT */
8875     if(cps->maxCores) { /* [HGM] SMP: (protocol specified must be last settings command before new!) */
8876       snprintf(buf, MSG_SIZ, "cores %d\n", appData.smpCores);
8877         SendToProgram(buf, cps);
8878     }
8879
8880     SendToProgram(cps->initString, cps);
8881     if (gameInfo.variant != VariantNormal &&
8882         gameInfo.variant != VariantLoadable
8883         /* [HGM] also send variant if board size non-standard */
8884         || gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0
8885                                             ) {
8886       char *v = VariantName(gameInfo.variant);
8887       if (cps->protocolVersion != 1 && StrStr(cps->variants, v) == NULL) {
8888         /* [HGM] in protocol 1 we have to assume all variants valid */
8889         snprintf(buf, MSG_SIZ, _("Variant %s not supported by %s"), v, cps->tidy);
8890         DisplayFatalError(buf, 0, 1);
8891         return;
8892       }
8893
8894       /* [HGM] make prefix for non-standard board size. Awkward testing... */
8895       overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
8896       if( gameInfo.variant == VariantXiangqi )
8897            overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 10 || gameInfo.holdingsSize != 0;
8898       if( gameInfo.variant == VariantShogi )
8899            overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 9 || gameInfo.holdingsSize != 7;
8900       if( gameInfo.variant == VariantBughouse || gameInfo.variant == VariantCrazyhouse )
8901            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 5;
8902       if( gameInfo.variant == VariantCapablanca || gameInfo.variant == VariantCapaRandom ||
8903                                gameInfo.variant == VariantGothic  || gameInfo.variant == VariantFalcon )
8904            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
8905       if( gameInfo.variant == VariantCourier )
8906            overruled = gameInfo.boardWidth != 12 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
8907       if( gameInfo.variant == VariantSuper )
8908            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
8909       if( gameInfo.variant == VariantGreat )
8910            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
8911       if( gameInfo.variant == VariantSChess )
8912            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 7;
8913
8914       if(overruled) {
8915         snprintf(b, MSG_SIZ, "%dx%d+%d_%s", gameInfo.boardWidth, gameInfo.boardHeight,
8916                  gameInfo.holdingsSize, VariantName(gameInfo.variant)); // cook up sized variant name
8917            /* [HGM] varsize: try first if this defiant size variant is specifically known */
8918            if(StrStr(cps->variants, b) == NULL) {
8919                // specific sized variant not known, check if general sizing allowed
8920                if (cps->protocolVersion != 1) { // for protocol 1 we cannot check and hope for the best
8921                    if(StrStr(cps->variants, "boardsize") == NULL) {
8922                      snprintf(buf, MSG_SIZ, "Board size %dx%d+%d not supported by %s",
8923                             gameInfo.boardWidth, gameInfo.boardHeight, gameInfo.holdingsSize, cps->tidy);
8924                        DisplayFatalError(buf, 0, 1);
8925                        return;
8926                    }
8927                    /* [HGM] here we really should compare with the maximum supported board size */
8928                }
8929            }
8930       } else snprintf(b, MSG_SIZ,"%s", VariantName(gameInfo.variant));
8931       snprintf(buf, MSG_SIZ, "variant %s\n", b);
8932       SendToProgram(buf, cps);
8933     }
8934     currentlyInitializedVariant = gameInfo.variant;
8935
8936     /* [HGM] send opening position in FRC to first engine */
8937     if(setup) {
8938           SendToProgram("force\n", cps);
8939           SendBoard(cps, 0);
8940           /* engine is now in force mode! Set flag to wake it up after first move. */
8941           setboardSpoiledMachineBlack = 1;
8942     }
8943
8944     if (cps->sendICS) {
8945       snprintf(buf, sizeof(buf), "ics %s\n", appData.icsActive ? appData.icsHost : "-");
8946       SendToProgram(buf, cps);
8947     }
8948     cps->maybeThinking = FALSE;
8949     cps->offeredDraw = 0;
8950     if (!appData.icsActive) {
8951         SendTimeControl(cps, movesPerSession, timeControl,
8952                         timeIncrement, appData.searchDepth,
8953                         searchTime);
8954     }
8955     if (appData.showThinking
8956         // [HGM] thinking: four options require thinking output to be sent
8957         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
8958                                 ) {
8959         SendToProgram("post\n", cps);
8960     }
8961     SendToProgram("hard\n", cps);
8962     if (!appData.ponderNextMove) {
8963         /* Warning: "easy" is a toggle in GNU Chess, so don't send
8964            it without being sure what state we are in first.  "hard"
8965            is not a toggle, so that one is OK.
8966          */
8967         SendToProgram("easy\n", cps);
8968     }
8969     if (cps->usePing) {
8970       snprintf(buf, MSG_SIZ, "ping %d\n", ++cps->lastPing);
8971       SendToProgram(buf, cps);
8972     }
8973     cps->initDone = TRUE;
8974 }
8975
8976
8977 void
8978 StartChessProgram(cps)
8979      ChessProgramState *cps;
8980 {
8981     char buf[MSG_SIZ];
8982     int err;
8983
8984     if (appData.noChessProgram) return;
8985     cps->initDone = FALSE;
8986
8987     if (strcmp(cps->host, "localhost") == 0) {
8988         err = StartChildProcess(cps->program, cps->dir, &cps->pr);
8989     } else if (*appData.remoteShell == NULLCHAR) {
8990         err = OpenRcmd(cps->host, appData.remoteUser, cps->program, &cps->pr);
8991     } else {
8992         if (*appData.remoteUser == NULLCHAR) {
8993           snprintf(buf, sizeof(buf), "%s %s %s", appData.remoteShell, cps->host,
8994                     cps->program);
8995         } else {
8996           snprintf(buf, sizeof(buf), "%s %s -l %s %s", appData.remoteShell,
8997                     cps->host, appData.remoteUser, cps->program);
8998         }
8999         err = StartChildProcess(buf, "", &cps->pr);
9000     }
9001
9002     if (err != 0) {
9003       snprintf(buf, MSG_SIZ, _("Startup failure on '%s'"), cps->program);
9004         DisplayFatalError(buf, err, 1);
9005         cps->pr = NoProc;
9006         cps->isr = NULL;
9007         return;
9008     }
9009
9010     cps->isr = AddInputSource(cps->pr, TRUE, ReceiveFromProgram, cps);
9011     if (cps->protocolVersion > 1) {
9012       snprintf(buf, MSG_SIZ, "xboard\nprotover %d\n", cps->protocolVersion);
9013       cps->nrOptions = 0; // [HGM] options: clear all engine-specific options
9014       cps->comboCnt = 0;  //                and values of combo boxes
9015       SendToProgram(buf, cps);
9016     } else {
9017       SendToProgram("xboard\n", cps);
9018     }
9019 }
9020
9021
9022 void
9023 TwoMachinesEventIfReady P((void))
9024 {
9025   if (first.lastPing != first.lastPong) {
9026     DisplayMessage("", _("Waiting for first chess program"));
9027     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
9028     return;
9029   }
9030   if (second.lastPing != second.lastPong) {
9031     DisplayMessage("", _("Waiting for second chess program"));
9032     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
9033     return;
9034   }
9035   ThawUI();
9036   TwoMachinesEvent();
9037 }
9038
9039 void
9040 NextMatchGame P((void))
9041 {
9042     int index; /* [HGM] autoinc: step load index during match */
9043     Reset(FALSE, TRUE);
9044     if (*appData.loadGameFile != NULLCHAR) {
9045         index = appData.loadGameIndex;
9046         if(index < 0) { // [HGM] autoinc
9047             lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
9048             if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
9049         }
9050         LoadGameFromFile(appData.loadGameFile,
9051                          index,
9052                          appData.loadGameFile, FALSE);
9053     } else if (*appData.loadPositionFile != NULLCHAR) {
9054         index = appData.loadPositionIndex;
9055         if(index < 0) { // [HGM] autoinc
9056             lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
9057             if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
9058         }
9059         LoadPositionFromFile(appData.loadPositionFile,
9060                              index,
9061                              appData.loadPositionFile);
9062     }
9063     TwoMachinesEventIfReady();
9064 }
9065
9066 void UserAdjudicationEvent( int result )
9067 {
9068     ChessMove gameResult = GameIsDrawn;
9069
9070     if( result > 0 ) {
9071         gameResult = WhiteWins;
9072     }
9073     else if( result < 0 ) {
9074         gameResult = BlackWins;
9075     }
9076
9077     if( gameMode == TwoMachinesPlay ) {
9078         GameEnds( gameResult, "User adjudication", GE_XBOARD );
9079     }
9080 }
9081
9082
9083 // [HGM] save: calculate checksum of game to make games easily identifiable
9084 int StringCheckSum(char *s)
9085 {
9086         int i = 0;
9087         if(s==NULL) return 0;
9088         while(*s) i = i*259 + *s++;
9089         return i;
9090 }
9091
9092 int GameCheckSum()
9093 {
9094         int i, sum=0;
9095         for(i=backwardMostMove; i<forwardMostMove; i++) {
9096                 sum += pvInfoList[i].depth;
9097                 sum += StringCheckSum(parseList[i]);
9098                 sum += StringCheckSum(commentList[i]);
9099                 sum *= 261;
9100         }
9101         if(i>1 && sum==0) sum++; // make sure never zero for non-empty game
9102         return sum + StringCheckSum(commentList[i]);
9103 } // end of save patch
9104
9105 void
9106 GameEnds(result, resultDetails, whosays)
9107      ChessMove result;
9108      char *resultDetails;
9109      int whosays;
9110 {
9111     GameMode nextGameMode;
9112     int isIcsGame;
9113     char buf[MSG_SIZ], popupRequested = 0;
9114
9115     if(endingGame) return; /* [HGM] crash: forbid recursion */
9116     endingGame = 1;
9117     if(twoBoards) { // [HGM] dual: switch back to one board
9118         twoBoards = partnerUp = 0; InitDrawingSizes(-2, 0);
9119         DrawPosition(TRUE, partnerBoard); // observed game becomes foreground
9120     }
9121     if (appData.debugMode) {
9122       fprintf(debugFP, "GameEnds(%d, %s, %d)\n",
9123               result, resultDetails ? resultDetails : "(null)", whosays);
9124     }
9125
9126     fromX = fromY = -1; // [HGM] abort any move the user is entering.
9127
9128     if (appData.icsActive && (whosays == GE_ENGINE || whosays >= GE_ENGINE1)) {
9129         /* If we are playing on ICS, the server decides when the
9130            game is over, but the engine can offer to draw, claim
9131            a draw, or resign.
9132          */
9133 #if ZIPPY
9134         if (appData.zippyPlay && first.initDone) {
9135             if (result == GameIsDrawn) {
9136                 /* In case draw still needs to be claimed */
9137                 SendToICS(ics_prefix);
9138                 SendToICS("draw\n");
9139             } else if (StrCaseStr(resultDetails, "resign")) {
9140                 SendToICS(ics_prefix);
9141                 SendToICS("resign\n");
9142             }
9143         }
9144 #endif
9145         endingGame = 0; /* [HGM] crash */
9146         return;
9147     }
9148
9149     /* If we're loading the game from a file, stop */
9150     if (whosays == GE_FILE) {
9151       (void) StopLoadGameTimer();
9152       gameFileFP = NULL;
9153     }
9154
9155     /* Cancel draw offers */
9156     first.offeredDraw = second.offeredDraw = 0;
9157
9158     /* If this is an ICS game, only ICS can really say it's done;
9159        if not, anyone can. */
9160     isIcsGame = (gameMode == IcsPlayingWhite ||
9161                  gameMode == IcsPlayingBlack ||
9162                  gameMode == IcsObserving    ||
9163                  gameMode == IcsExamining);
9164
9165     if (!isIcsGame || whosays == GE_ICS) {
9166         /* OK -- not an ICS game, or ICS said it was done */
9167         StopClocks();
9168         if (!isIcsGame && !appData.noChessProgram)
9169           SetUserThinkingEnables();
9170
9171         /* [HGM] if a machine claims the game end we verify this claim */
9172         if(gameMode == TwoMachinesPlay && appData.testClaims) {
9173             if(appData.testLegality && whosays >= GE_ENGINE1 ) {
9174                 char claimer;
9175                 ChessMove trueResult = (ChessMove) -1;
9176
9177                 claimer = whosays == GE_ENGINE1 ?      /* color of claimer */
9178                                             first.twoMachinesColor[0] :
9179                                             second.twoMachinesColor[0] ;
9180
9181                 // [HGM] losers: because the logic is becoming a bit hairy, determine true result first
9182                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_CHECKMATE) {
9183                     /* [HGM] verify: engine mate claims accepted if they were flagged */
9184                     trueResult = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins;
9185                 } else
9186                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_WINS) { // added code for games where being mated is a win
9187                     /* [HGM] verify: engine mate claims accepted if they were flagged */
9188                     trueResult = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
9189                 } else
9190                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_STALEMATE) { // only used to indicate draws now
9191                     trueResult = GameIsDrawn; // default; in variants where stalemate loses, Status is CHECKMATE
9192                 }
9193
9194                 // now verify win claims, but not in drop games, as we don't understand those yet
9195                 if( (gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
9196                                                  || gameInfo.variant == VariantGreat) &&
9197                     (result == WhiteWins && claimer == 'w' ||
9198                      result == BlackWins && claimer == 'b'   ) ) { // case to verify: engine claims own win
9199                       if (appData.debugMode) {
9200                         fprintf(debugFP, "result=%d sp=%d move=%d\n",
9201                                 result, (signed char)boards[forwardMostMove][EP_STATUS], forwardMostMove);
9202                       }
9203                       if(result != trueResult) {
9204                         snprintf(buf, MSG_SIZ, "False win claim: '%s'", resultDetails);
9205                               result = claimer == 'w' ? BlackWins : WhiteWins;
9206                               resultDetails = buf;
9207                       }
9208                 } else
9209                 if( result == GameIsDrawn && (signed char)boards[forwardMostMove][EP_STATUS] > EP_DRAWS
9210                     && (forwardMostMove <= backwardMostMove ||
9211                         (signed char)boards[forwardMostMove-1][EP_STATUS] > EP_DRAWS ||
9212                         (claimer=='b')==(forwardMostMove&1))
9213                                                                                   ) {
9214                       /* [HGM] verify: draws that were not flagged are false claims */
9215                   snprintf(buf, MSG_SIZ, "False draw claim: '%s'", resultDetails);
9216                       result = claimer == 'w' ? BlackWins : WhiteWins;
9217                       resultDetails = buf;
9218                 }
9219                 /* (Claiming a loss is accepted no questions asked!) */
9220             }
9221             /* [HGM] bare: don't allow bare King to win */
9222             if((gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
9223                && gameInfo.variant != VariantLosers && gameInfo.variant != VariantGiveaway
9224                && gameInfo.variant != VariantSuicide // [HGM] losers: except in losers, of course...
9225                && result != GameIsDrawn)
9226             {   int i, j, k=0, color = (result==WhiteWins ? (int)WhitePawn : (int)BlackPawn);
9227                 for(j=BOARD_LEFT; j<BOARD_RGHT; j++) for(i=0; i<BOARD_HEIGHT; i++) {
9228                         int p = (signed char)boards[forwardMostMove][i][j] - color;
9229                         if(p >= 0 && p <= (int)WhiteKing) k++;
9230                 }
9231                 if (appData.debugMode) {
9232                      fprintf(debugFP, "GE(%d, %s, %d) bare king k=%d color=%d\n",
9233                         result, resultDetails ? resultDetails : "(null)", whosays, k, color);
9234                 }
9235                 if(k <= 1) {
9236                         result = GameIsDrawn;
9237                         snprintf(buf, MSG_SIZ, "%s but bare king", resultDetails);
9238                         resultDetails = buf;
9239                 }
9240             }
9241         }
9242
9243
9244         if(serverMoves != NULL && !loadFlag) { char c = '=';
9245             if(result==WhiteWins) c = '+';
9246             if(result==BlackWins) c = '-';
9247             if(resultDetails != NULL)
9248                 fprintf(serverMoves, ";%c;%s\n", c, resultDetails);
9249         }
9250         if (resultDetails != NULL) {
9251             gameInfo.result = result;
9252             gameInfo.resultDetails = StrSave(resultDetails);
9253
9254             /* display last move only if game was not loaded from file */
9255             if ((whosays != GE_FILE) && (currentMove == forwardMostMove))
9256                 DisplayMove(currentMove - 1);
9257
9258             if (forwardMostMove != 0) {
9259                 if (gameMode != PlayFromGameFile && gameMode != EditGame
9260                     && lastSavedGame != GameCheckSum() // [HGM] save: suppress duplicates
9261                                                                 ) {
9262                     if (*appData.saveGameFile != NULLCHAR) {
9263                         SaveGameToFile(appData.saveGameFile, TRUE);
9264                     } else if (appData.autoSaveGames) {
9265                         AutoSaveGame();
9266                     }
9267                     if (*appData.savePositionFile != NULLCHAR) {
9268                         SavePositionToFile(appData.savePositionFile);
9269                     }
9270                 }
9271             }
9272
9273             /* Tell program how game ended in case it is learning */
9274             /* [HGM] Moved this to after saving the PGN, just in case */
9275             /* engine died and we got here through time loss. In that */
9276             /* case we will get a fatal error writing the pipe, which */
9277             /* would otherwise lose us the PGN.                       */
9278             /* [HGM] crash: not needed anymore, but doesn't hurt;     */
9279             /* output during GameEnds should never be fatal anymore   */
9280             if (gameMode == MachinePlaysWhite ||
9281                 gameMode == MachinePlaysBlack ||
9282                 gameMode == TwoMachinesPlay ||
9283                 gameMode == IcsPlayingWhite ||
9284                 gameMode == IcsPlayingBlack ||
9285                 gameMode == BeginningOfGame) {
9286                 char buf[MSG_SIZ];
9287                 snprintf(buf, MSG_SIZ, "result %s {%s}\n", PGNResult(result),
9288                         resultDetails);
9289                 if (first.pr != NoProc) {
9290                     SendToProgram(buf, &first);
9291                 }
9292                 if (second.pr != NoProc &&
9293                     gameMode == TwoMachinesPlay) {
9294                     SendToProgram(buf, &second);
9295                 }
9296             }
9297         }
9298
9299         if (appData.icsActive) {
9300             if (appData.quietPlay &&
9301                 (gameMode == IcsPlayingWhite ||
9302                  gameMode == IcsPlayingBlack)) {
9303                 SendToICS(ics_prefix);
9304                 SendToICS("set shout 1\n");
9305             }
9306             nextGameMode = IcsIdle;
9307             ics_user_moved = FALSE;
9308             /* clean up premove.  It's ugly when the game has ended and the
9309              * premove highlights are still on the board.
9310              */
9311             if (gotPremove) {
9312               gotPremove = FALSE;
9313               ClearPremoveHighlights();
9314               DrawPosition(FALSE, boards[currentMove]);
9315             }
9316             if (whosays == GE_ICS) {
9317                 switch (result) {
9318                 case WhiteWins:
9319                     if (gameMode == IcsPlayingWhite)
9320                         PlayIcsWinSound();
9321                     else if(gameMode == IcsPlayingBlack)
9322                         PlayIcsLossSound();
9323                     break;
9324                 case BlackWins:
9325                     if (gameMode == IcsPlayingBlack)
9326                         PlayIcsWinSound();
9327                     else if(gameMode == IcsPlayingWhite)
9328                         PlayIcsLossSound();
9329                     break;
9330                 case GameIsDrawn:
9331                     PlayIcsDrawSound();
9332                     break;
9333                 default:
9334                     PlayIcsUnfinishedSound();
9335                 }
9336             }
9337         } else if (gameMode == EditGame ||
9338                    gameMode == PlayFromGameFile ||
9339                    gameMode == AnalyzeMode ||
9340                    gameMode == AnalyzeFile) {
9341             nextGameMode = gameMode;
9342         } else {
9343             nextGameMode = EndOfGame;
9344         }
9345         pausing = FALSE;
9346         ModeHighlight();
9347     } else {
9348         nextGameMode = gameMode;
9349     }
9350
9351     if (appData.noChessProgram) {
9352         gameMode = nextGameMode;
9353         ModeHighlight();
9354         endingGame = 0; /* [HGM] crash */
9355         return;
9356     }
9357
9358     if (first.reuse) {
9359         /* Put first chess program into idle state */
9360         if (first.pr != NoProc &&
9361             (gameMode == MachinePlaysWhite ||
9362              gameMode == MachinePlaysBlack ||
9363              gameMode == TwoMachinesPlay ||
9364              gameMode == IcsPlayingWhite ||
9365              gameMode == IcsPlayingBlack ||
9366              gameMode == BeginningOfGame)) {
9367             SendToProgram("force\n", &first);
9368             if (first.usePing) {
9369               char buf[MSG_SIZ];
9370               snprintf(buf, MSG_SIZ, "ping %d\n", ++first.lastPing);
9371               SendToProgram(buf, &first);
9372             }
9373         }
9374     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
9375         /* Kill off first chess program */
9376         if (first.isr != NULL)
9377           RemoveInputSource(first.isr);
9378         first.isr = NULL;
9379
9380         if (first.pr != NoProc) {
9381             ExitAnalyzeMode();
9382             DoSleep( appData.delayBeforeQuit );
9383             SendToProgram("quit\n", &first);
9384             DoSleep( appData.delayAfterQuit );
9385             DestroyChildProcess(first.pr, first.useSigterm);
9386         }
9387         first.pr = NoProc;
9388     }
9389     if (second.reuse) {
9390         /* Put second chess program into idle state */
9391         if (second.pr != NoProc &&
9392             gameMode == TwoMachinesPlay) {
9393             SendToProgram("force\n", &second);
9394             if (second.usePing) {
9395               char buf[MSG_SIZ];
9396               snprintf(buf, MSG_SIZ, "ping %d\n", ++second.lastPing);
9397               SendToProgram(buf, &second);
9398             }
9399         }
9400     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
9401         /* Kill off second chess program */
9402         if (second.isr != NULL)
9403           RemoveInputSource(second.isr);
9404         second.isr = NULL;
9405
9406         if (second.pr != NoProc) {
9407             DoSleep( appData.delayBeforeQuit );
9408             SendToProgram("quit\n", &second);
9409             DoSleep( appData.delayAfterQuit );
9410             DestroyChildProcess(second.pr, second.useSigterm);
9411         }
9412         second.pr = NoProc;
9413     }
9414
9415     if (matchMode && gameMode == TwoMachinesPlay) {
9416         switch (result) {
9417         case WhiteWins:
9418           if (first.twoMachinesColor[0] == 'w') {
9419             first.matchWins++;
9420           } else {
9421             second.matchWins++;
9422           }
9423           break;
9424         case BlackWins:
9425           if (first.twoMachinesColor[0] == 'b') {
9426             first.matchWins++;
9427           } else {
9428             second.matchWins++;
9429           }
9430           break;
9431         default:
9432           break;
9433         }
9434         if (matchGame < appData.matchGames) {
9435             char *tmp;
9436             if(appData.sameColorGames <= 1) { /* [HGM] alternate: suppress color swap */
9437                 tmp = first.twoMachinesColor;
9438                 first.twoMachinesColor = second.twoMachinesColor;
9439                 second.twoMachinesColor = tmp;
9440             }
9441             gameMode = nextGameMode;
9442             matchGame++;
9443             if(appData.matchPause>10000 || appData.matchPause<10)
9444                 appData.matchPause = 10000; /* [HGM] make pause adjustable */
9445             ScheduleDelayedEvent(NextMatchGame, appData.matchPause);
9446             endingGame = 0; /* [HGM] crash */
9447             return;
9448         } else {
9449             gameMode = nextGameMode;
9450             snprintf(buf, MSG_SIZ, _("Match %s vs. %s: final score %d-%d-%d"),
9451                      first.tidy, second.tidy,
9452                      first.matchWins, second.matchWins,
9453                      appData.matchGames - (first.matchWins + second.matchWins));
9454             popupRequested++; // [HGM] crash: postpone to after resetting endingGame
9455         }
9456     }
9457     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile) &&
9458         !(nextGameMode == AnalyzeMode || nextGameMode == AnalyzeFile))
9459       ExitAnalyzeMode();
9460     gameMode = nextGameMode;
9461     ModeHighlight();
9462     endingGame = 0;  /* [HGM] crash */
9463     if(popupRequested) { // [HGM] crash: this calls GameEnds recursively through ExitEvent! Make it a harmless tail recursion.
9464       if(matchMode == TRUE) DisplayFatalError(buf, 0, 0); else {
9465         matchMode = FALSE; appData.matchGames = matchGame = 0;
9466         DisplayNote(buf);
9467       }
9468     }
9469 }
9470
9471 /* Assumes program was just initialized (initString sent).
9472    Leaves program in force mode. */
9473 void
9474 FeedMovesToProgram(cps, upto)
9475      ChessProgramState *cps;
9476      int upto;
9477 {
9478     int i;
9479
9480     if (appData.debugMode)
9481       fprintf(debugFP, "Feeding %smoves %d through %d to %s chess program\n",
9482               startedFromSetupPosition ? "position and " : "",
9483               backwardMostMove, upto, cps->which);
9484     if(currentlyInitializedVariant != gameInfo.variant) {
9485       char buf[MSG_SIZ];
9486         // [HGM] variantswitch: make engine aware of new variant
9487         if(cps->protocolVersion > 1 && StrStr(cps->variants, VariantName(gameInfo.variant)) == NULL)
9488                 return; // [HGM] refrain from feeding moves altogether if variant is unsupported!
9489         snprintf(buf, MSG_SIZ, "variant %s\n", VariantName(gameInfo.variant));
9490         SendToProgram(buf, cps);
9491         currentlyInitializedVariant = gameInfo.variant;
9492     }
9493     SendToProgram("force\n", cps);
9494     if (startedFromSetupPosition) {
9495         SendBoard(cps, backwardMostMove);
9496     if (appData.debugMode) {
9497         fprintf(debugFP, "feedMoves\n");
9498     }
9499     }
9500     for (i = backwardMostMove; i < upto; i++) {
9501         SendMoveToProgram(i, cps);
9502     }
9503 }
9504
9505
9506 void
9507 ResurrectChessProgram()
9508 {
9509      /* The chess program may have exited.
9510         If so, restart it and feed it all the moves made so far. */
9511
9512     if (appData.noChessProgram || first.pr != NoProc) return;
9513
9514     StartChessProgram(&first);
9515     InitChessProgram(&first, FALSE);
9516     FeedMovesToProgram(&first, currentMove);
9517
9518     if (!first.sendTime) {
9519         /* can't tell gnuchess what its clock should read,
9520            so we bow to its notion. */
9521         ResetClocks();
9522         timeRemaining[0][currentMove] = whiteTimeRemaining;
9523         timeRemaining[1][currentMove] = blackTimeRemaining;
9524     }
9525
9526     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile ||
9527                 appData.icsEngineAnalyze) && first.analysisSupport) {
9528       SendToProgram("analyze\n", &first);
9529       first.analyzing = TRUE;
9530     }
9531 }
9532
9533 /*
9534  * Button procedures
9535  */
9536 void
9537 Reset(redraw, init)
9538      int redraw, init;
9539 {
9540     int i;
9541
9542     if (appData.debugMode) {
9543         fprintf(debugFP, "Reset(%d, %d) from gameMode %d\n",
9544                 redraw, init, gameMode);
9545     }
9546     CleanupTail(); // [HGM] vari: delete any stored variations
9547     pausing = pauseExamInvalid = FALSE;
9548     startedFromSetupPosition = blackPlaysFirst = FALSE;
9549     firstMove = TRUE;
9550     whiteFlag = blackFlag = FALSE;
9551     userOfferedDraw = FALSE;
9552     hintRequested = bookRequested = FALSE;
9553     first.maybeThinking = FALSE;
9554     second.maybeThinking = FALSE;
9555     first.bookSuspend = FALSE; // [HGM] book
9556     second.bookSuspend = FALSE;
9557     thinkOutput[0] = NULLCHAR;
9558     lastHint[0] = NULLCHAR;
9559     ClearGameInfo(&gameInfo);
9560     gameInfo.variant = StringToVariant(appData.variant);
9561     ics_user_moved = ics_clock_paused = FALSE;
9562     ics_getting_history = H_FALSE;
9563     ics_gamenum = -1;
9564     white_holding[0] = black_holding[0] = NULLCHAR;
9565     ClearProgramStats();
9566     opponentKibitzes = FALSE; // [HGM] kibitz: do not reserve space in engine-output window in zippy mode
9567
9568     ResetFrontEnd();
9569     ClearHighlights();
9570     flipView = appData.flipView;
9571     ClearPremoveHighlights();
9572     gotPremove = FALSE;
9573     alarmSounded = FALSE;
9574
9575     GameEnds(EndOfFile, NULL, GE_PLAYER);
9576     if(appData.serverMovesName != NULL) {
9577         /* [HGM] prepare to make moves file for broadcasting */
9578         clock_t t = clock();
9579         if(serverMoves != NULL) fclose(serverMoves);
9580         serverMoves = fopen(appData.serverMovesName, "r");
9581         if(serverMoves != NULL) {
9582             fclose(serverMoves);
9583             /* delay 15 sec before overwriting, so all clients can see end */
9584             while(clock()-t < appData.serverPause*CLOCKS_PER_SEC);
9585         }
9586         serverMoves = fopen(appData.serverMovesName, "w");
9587     }
9588
9589     ExitAnalyzeMode();
9590     gameMode = BeginningOfGame;
9591     ModeHighlight();
9592     if(appData.icsActive) gameInfo.variant = VariantNormal;
9593     currentMove = forwardMostMove = backwardMostMove = 0;
9594     InitPosition(redraw);
9595     for (i = 0; i < MAX_MOVES; i++) {
9596         if (commentList[i] != NULL) {
9597             free(commentList[i]);
9598             commentList[i] = NULL;
9599         }
9600     }
9601     ResetClocks();
9602     timeRemaining[0][0] = whiteTimeRemaining;
9603     timeRemaining[1][0] = blackTimeRemaining;
9604     if (first.pr == NULL) {
9605         StartChessProgram(&first);
9606     }
9607     if (init) {
9608             InitChessProgram(&first, startedFromSetupPosition);
9609     }
9610     DisplayTitle("");
9611     DisplayMessage("", "");
9612     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
9613     lastSavedGame = 0; // [HGM] save: make sure next game counts as unsaved
9614 }
9615
9616 void
9617 AutoPlayGameLoop()
9618 {
9619     for (;;) {
9620         if (!AutoPlayOneMove())
9621           return;
9622         if (matchMode || appData.timeDelay == 0)
9623           continue;
9624         if (appData.timeDelay < 0 || gameMode == AnalyzeFile)
9625           return;
9626         StartLoadGameTimer((long)(1000.0 * appData.timeDelay));
9627         break;
9628     }
9629 }
9630
9631
9632 int
9633 AutoPlayOneMove()
9634 {
9635     int fromX, fromY, toX, toY;
9636
9637     if (appData.debugMode) {
9638       fprintf(debugFP, "AutoPlayOneMove(): current %d\n", currentMove);
9639     }
9640
9641     if (gameMode != PlayFromGameFile)
9642       return FALSE;
9643
9644     if (currentMove >= forwardMostMove) {
9645       gameMode = EditGame;
9646       ModeHighlight();
9647
9648       /* [AS] Clear current move marker at the end of a game */
9649       /* HistorySet(parseList, backwardMostMove, forwardMostMove, -1); */
9650
9651       return FALSE;
9652     }
9653
9654     toX = moveList[currentMove][2] - AAA;
9655     toY = moveList[currentMove][3] - ONE;
9656
9657     if (moveList[currentMove][1] == '@') {
9658         if (appData.highlightLastMove) {
9659             SetHighlights(-1, -1, toX, toY);
9660         }
9661     } else {
9662         fromX = moveList[currentMove][0] - AAA;
9663         fromY = moveList[currentMove][1] - ONE;
9664
9665         HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove); /* [AS] */
9666
9667         AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
9668
9669         if (appData.highlightLastMove) {
9670             SetHighlights(fromX, fromY, toX, toY);
9671         }
9672     }
9673     DisplayMove(currentMove);
9674     SendMoveToProgram(currentMove++, &first);
9675     DisplayBothClocks();
9676     DrawPosition(FALSE, boards[currentMove]);
9677     // [HGM] PV info: always display, routine tests if empty
9678     DisplayComment(currentMove - 1, commentList[currentMove]);
9679     return TRUE;
9680 }
9681
9682
9683 int
9684 LoadGameOneMove(readAhead)
9685      ChessMove readAhead;
9686 {
9687     int fromX = 0, fromY = 0, toX = 0, toY = 0, done;
9688     char promoChar = NULLCHAR;
9689     ChessMove moveType;
9690     char move[MSG_SIZ];
9691     char *p, *q;
9692
9693     if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile &&
9694         gameMode != AnalyzeMode && gameMode != Training) {
9695         gameFileFP = NULL;
9696         return FALSE;
9697     }
9698
9699     yyboardindex = forwardMostMove;
9700     if (readAhead != EndOfFile) {
9701       moveType = readAhead;
9702     } else {
9703       if (gameFileFP == NULL)
9704           return FALSE;
9705       moveType = (ChessMove) Myylex();
9706     }
9707
9708     done = FALSE;
9709     switch (moveType) {
9710       case Comment:
9711         if (appData.debugMode)
9712           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
9713         p = yy_text;
9714
9715         /* append the comment but don't display it */
9716         AppendComment(currentMove, p, FALSE);
9717         return TRUE;
9718
9719       case WhiteCapturesEnPassant:
9720       case BlackCapturesEnPassant:
9721       case WhitePromotion:
9722       case BlackPromotion:
9723       case WhiteNonPromotion:
9724       case BlackNonPromotion:
9725       case NormalMove:
9726       case WhiteKingSideCastle:
9727       case WhiteQueenSideCastle:
9728       case BlackKingSideCastle:
9729       case BlackQueenSideCastle:
9730       case WhiteKingSideCastleWild:
9731       case WhiteQueenSideCastleWild:
9732       case BlackKingSideCastleWild:
9733       case BlackQueenSideCastleWild:
9734       /* PUSH Fabien */
9735       case WhiteHSideCastleFR:
9736       case WhiteASideCastleFR:
9737       case BlackHSideCastleFR:
9738       case BlackASideCastleFR:
9739       /* POP Fabien */
9740         if (appData.debugMode)
9741           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
9742         fromX = currentMoveString[0] - AAA;
9743         fromY = currentMoveString[1] - ONE;
9744         toX = currentMoveString[2] - AAA;
9745         toY = currentMoveString[3] - ONE;
9746         promoChar = currentMoveString[4];
9747         break;
9748
9749       case WhiteDrop:
9750       case BlackDrop:
9751         if (appData.debugMode)
9752           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
9753         fromX = moveType == WhiteDrop ?
9754           (int) CharToPiece(ToUpper(currentMoveString[0])) :
9755         (int) CharToPiece(ToLower(currentMoveString[0]));
9756         fromY = DROP_RANK;
9757         toX = currentMoveString[2] - AAA;
9758         toY = currentMoveString[3] - ONE;
9759         break;
9760
9761       case WhiteWins:
9762       case BlackWins:
9763       case GameIsDrawn:
9764       case GameUnfinished:
9765         if (appData.debugMode)
9766           fprintf(debugFP, "Parsed game end: %s\n", yy_text);
9767         p = strchr(yy_text, '{');
9768         if (p == NULL) p = strchr(yy_text, '(');
9769         if (p == NULL) {
9770             p = yy_text;
9771             if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
9772         } else {
9773             q = strchr(p, *p == '{' ? '}' : ')');
9774             if (q != NULL) *q = NULLCHAR;
9775             p++;
9776         }
9777         GameEnds(moveType, p, GE_FILE);
9778         done = TRUE;
9779         if (cmailMsgLoaded) {
9780             ClearHighlights();
9781             flipView = WhiteOnMove(currentMove);
9782             if (moveType == GameUnfinished) flipView = !flipView;
9783             if (appData.debugMode)
9784               fprintf(debugFP, "Setting flipView to %d\n", flipView) ;
9785         }
9786         break;
9787
9788       case EndOfFile:
9789         if (appData.debugMode)
9790           fprintf(debugFP, "Parser hit end of file\n");
9791         switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
9792           case MT_NONE:
9793           case MT_CHECK:
9794             break;
9795           case MT_CHECKMATE:
9796           case MT_STAINMATE:
9797             if (WhiteOnMove(currentMove)) {
9798                 GameEnds(BlackWins, "Black mates", GE_FILE);
9799             } else {
9800                 GameEnds(WhiteWins, "White mates", GE_FILE);
9801             }
9802             break;
9803           case MT_STALEMATE:
9804             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
9805             break;
9806         }
9807         done = TRUE;
9808         break;
9809
9810       case MoveNumberOne:
9811         if (lastLoadGameStart == GNUChessGame) {
9812             /* GNUChessGames have numbers, but they aren't move numbers */
9813             if (appData.debugMode)
9814               fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
9815                       yy_text, (int) moveType);
9816             return LoadGameOneMove(EndOfFile); /* tail recursion */
9817         }
9818         /* else fall thru */
9819
9820       case XBoardGame:
9821       case GNUChessGame:
9822       case PGNTag:
9823         /* Reached start of next game in file */
9824         if (appData.debugMode)
9825           fprintf(debugFP, "Parsed start of next game: %s\n", yy_text);
9826         switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
9827           case MT_NONE:
9828           case MT_CHECK:
9829             break;
9830           case MT_CHECKMATE:
9831           case MT_STAINMATE:
9832             if (WhiteOnMove(currentMove)) {
9833                 GameEnds(BlackWins, "Black mates", GE_FILE);
9834             } else {
9835                 GameEnds(WhiteWins, "White mates", GE_FILE);
9836             }
9837             break;
9838           case MT_STALEMATE:
9839             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
9840             break;
9841         }
9842         done = TRUE;
9843         break;
9844
9845       case PositionDiagram:     /* should not happen; ignore */
9846       case ElapsedTime:         /* ignore */
9847       case NAG:                 /* ignore */
9848         if (appData.debugMode)
9849           fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
9850                   yy_text, (int) moveType);
9851         return LoadGameOneMove(EndOfFile); /* tail recursion */
9852
9853       case IllegalMove:
9854         if (appData.testLegality) {
9855             if (appData.debugMode)
9856               fprintf(debugFP, "Parsed IllegalMove: %s\n", yy_text);
9857             snprintf(move, MSG_SIZ, _("Illegal move: %d.%s%s"),
9858                     (forwardMostMove / 2) + 1,
9859                     WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
9860             DisplayError(move, 0);
9861             done = TRUE;
9862         } else {
9863             if (appData.debugMode)
9864               fprintf(debugFP, "Parsed %s into IllegalMove %s\n",
9865                       yy_text, currentMoveString);
9866             fromX = currentMoveString[0] - AAA;
9867             fromY = currentMoveString[1] - ONE;
9868             toX = currentMoveString[2] - AAA;
9869             toY = currentMoveString[3] - ONE;
9870             promoChar = currentMoveString[4];
9871         }
9872         break;
9873
9874       case AmbiguousMove:
9875         if (appData.debugMode)
9876           fprintf(debugFP, "Parsed AmbiguousMove: %s\n", yy_text);
9877         snprintf(move, MSG_SIZ, _("Ambiguous move: %d.%s%s"),
9878                 (forwardMostMove / 2) + 1,
9879                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
9880         DisplayError(move, 0);
9881         done = TRUE;
9882         break;
9883
9884       default:
9885       case ImpossibleMove:
9886         if (appData.debugMode)
9887           fprintf(debugFP, "Parsed ImpossibleMove (type = %d): %s\n", moveType, yy_text);
9888         snprintf(move, MSG_SIZ, _("Illegal move: %d.%s%s"),
9889                 (forwardMostMove / 2) + 1,
9890                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
9891         DisplayError(move, 0);
9892         done = TRUE;
9893         break;
9894     }
9895
9896     if (done) {
9897         if (appData.matchMode || (appData.timeDelay == 0 && !pausing)) {
9898             DrawPosition(FALSE, boards[currentMove]);
9899             DisplayBothClocks();
9900             if (!appData.matchMode) // [HGM] PV info: routine tests if empty
9901               DisplayComment(currentMove - 1, commentList[currentMove]);
9902         }
9903         (void) StopLoadGameTimer();
9904         gameFileFP = NULL;
9905         cmailOldMove = forwardMostMove;
9906         return FALSE;
9907     } else {
9908         /* currentMoveString is set as a side-effect of yylex */
9909         strcat(currentMoveString, "\n");
9910         safeStrCpy(moveList[forwardMostMove], currentMoveString, sizeof(moveList[forwardMostMove])/sizeof(moveList[forwardMostMove][0]));
9911
9912         thinkOutput[0] = NULLCHAR;
9913         MakeMove(fromX, fromY, toX, toY, promoChar);
9914         currentMove = forwardMostMove;
9915         return TRUE;
9916     }
9917 }
9918
9919 /* Load the nth game from the given file */
9920 int
9921 LoadGameFromFile(filename, n, title, useList)
9922      char *filename;
9923      int n;
9924      char *title;
9925      /*Boolean*/ int useList;
9926 {
9927     FILE *f;
9928     char buf[MSG_SIZ];
9929
9930     if (strcmp(filename, "-") == 0) {
9931         f = stdin;
9932         title = "stdin";
9933     } else {
9934         f = fopen(filename, "rb");
9935         if (f == NULL) {
9936           snprintf(buf, sizeof(buf),  _("Can't open \"%s\""), filename);
9937             DisplayError(buf, errno);
9938             return FALSE;
9939         }
9940     }
9941     if (fseek(f, 0, 0) == -1) {
9942         /* f is not seekable; probably a pipe */
9943         useList = FALSE;
9944     }
9945     if (useList && n == 0) {
9946         int error = GameListBuild(f);
9947         if (error) {
9948             DisplayError(_("Cannot build game list"), error);
9949         } else if (!ListEmpty(&gameList) &&
9950                    ((ListGame *) gameList.tailPred)->number > 1) {
9951             GameListPopUp(f, title);
9952             return TRUE;
9953         }
9954         GameListDestroy();
9955         n = 1;
9956     }
9957     if (n == 0) n = 1;
9958     return LoadGame(f, n, title, FALSE);
9959 }
9960
9961
9962 void
9963 MakeRegisteredMove()
9964 {
9965     int fromX, fromY, toX, toY;
9966     char promoChar;
9967     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
9968         switch (cmailMoveType[lastLoadGameNumber - 1]) {
9969           case CMAIL_MOVE:
9970           case CMAIL_DRAW:
9971             if (appData.debugMode)
9972               fprintf(debugFP, "Restoring %s for game %d\n",
9973                       cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
9974
9975             thinkOutput[0] = NULLCHAR;
9976             safeStrCpy(moveList[currentMove], cmailMove[lastLoadGameNumber - 1], sizeof(moveList[currentMove])/sizeof(moveList[currentMove][0]));
9977             fromX = cmailMove[lastLoadGameNumber - 1][0] - AAA;
9978             fromY = cmailMove[lastLoadGameNumber - 1][1] - ONE;
9979             toX = cmailMove[lastLoadGameNumber - 1][2] - AAA;
9980             toY = cmailMove[lastLoadGameNumber - 1][3] - ONE;
9981             promoChar = cmailMove[lastLoadGameNumber - 1][4];
9982             MakeMove(fromX, fromY, toX, toY, promoChar);
9983             ShowMove(fromX, fromY, toX, toY);
9984
9985             switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
9986               case MT_NONE:
9987               case MT_CHECK:
9988                 break;
9989
9990               case MT_CHECKMATE:
9991               case MT_STAINMATE:
9992                 if (WhiteOnMove(currentMove)) {
9993                     GameEnds(BlackWins, "Black mates", GE_PLAYER);
9994                 } else {
9995                     GameEnds(WhiteWins, "White mates", GE_PLAYER);
9996                 }
9997                 break;
9998
9999               case MT_STALEMATE:
10000                 GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
10001                 break;
10002             }
10003
10004             break;
10005
10006           case CMAIL_RESIGN:
10007             if (WhiteOnMove(currentMove)) {
10008                 GameEnds(BlackWins, "White resigns", GE_PLAYER);
10009             } else {
10010                 GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
10011             }
10012             break;
10013
10014           case CMAIL_ACCEPT:
10015             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
10016             break;
10017
10018           default:
10019             break;
10020         }
10021     }
10022
10023     return;
10024 }
10025
10026 /* Wrapper around LoadGame for use when a Cmail message is loaded */
10027 int
10028 CmailLoadGame(f, gameNumber, title, useList)
10029      FILE *f;
10030      int gameNumber;
10031      char *title;
10032      int useList;
10033 {
10034     int retVal;
10035
10036     if (gameNumber > nCmailGames) {
10037         DisplayError(_("No more games in this message"), 0);
10038         return FALSE;
10039     }
10040     if (f == lastLoadGameFP) {
10041         int offset = gameNumber - lastLoadGameNumber;
10042         if (offset == 0) {
10043             cmailMsg[0] = NULLCHAR;
10044             if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
10045                 cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
10046                 nCmailMovesRegistered--;
10047             }
10048             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
10049             if (cmailResult[lastLoadGameNumber - 1] == CMAIL_NEW_RESULT) {
10050                 cmailResult[lastLoadGameNumber - 1] = CMAIL_NOT_RESULT;
10051             }
10052         } else {
10053             if (! RegisterMove()) return FALSE;
10054         }
10055     }
10056
10057     retVal = LoadGame(f, gameNumber, title, useList);
10058
10059     /* Make move registered during previous look at this game, if any */
10060     MakeRegisteredMove();
10061
10062     if (cmailCommentList[lastLoadGameNumber - 1] != NULL) {
10063         commentList[currentMove]
10064           = StrSave(cmailCommentList[lastLoadGameNumber - 1]);
10065         DisplayComment(currentMove - 1, commentList[currentMove]);
10066     }
10067
10068     return retVal;
10069 }
10070
10071 /* Support for LoadNextGame, LoadPreviousGame, ReloadSameGame */
10072 int
10073 ReloadGame(offset)
10074      int offset;
10075 {
10076     int gameNumber = lastLoadGameNumber + offset;
10077     if (lastLoadGameFP == NULL) {
10078         DisplayError(_("No game has been loaded yet"), 0);
10079         return FALSE;
10080     }
10081     if (gameNumber <= 0) {
10082         DisplayError(_("Can't back up any further"), 0);
10083         return FALSE;
10084     }
10085     if (cmailMsgLoaded) {
10086         return CmailLoadGame(lastLoadGameFP, gameNumber,
10087                              lastLoadGameTitle, lastLoadGameUseList);
10088     } else {
10089         return LoadGame(lastLoadGameFP, gameNumber,
10090                         lastLoadGameTitle, lastLoadGameUseList);
10091     }
10092 }
10093
10094
10095
10096 /* Load the nth game from open file f */
10097 int
10098 LoadGame(f, gameNumber, title, useList)
10099      FILE *f;
10100      int gameNumber;
10101      char *title;
10102      int useList;
10103 {
10104     ChessMove cm;
10105     char buf[MSG_SIZ];
10106     int gn = gameNumber;
10107     ListGame *lg = NULL;
10108     int numPGNTags = 0;
10109     int err;
10110     GameMode oldGameMode;
10111     VariantClass oldVariant = gameInfo.variant; /* [HGM] PGNvariant */
10112
10113     if (appData.debugMode)
10114         fprintf(debugFP, "LoadGame(): on entry, gameMode %d\n", gameMode);
10115
10116     if (gameMode == Training )
10117         SetTrainingModeOff();
10118
10119     oldGameMode = gameMode;
10120     if (gameMode != BeginningOfGame) {
10121       Reset(FALSE, TRUE);
10122     }
10123
10124     gameFileFP = f;
10125     if (lastLoadGameFP != NULL && lastLoadGameFP != f) {
10126         fclose(lastLoadGameFP);
10127     }
10128
10129     if (useList) {
10130         lg = (ListGame *) ListElem(&gameList, gameNumber-1);
10131
10132         if (lg) {
10133             fseek(f, lg->offset, 0);
10134             GameListHighlight(gameNumber);
10135             gn = 1;
10136         }
10137         else {
10138             DisplayError(_("Game number out of range"), 0);
10139             return FALSE;
10140         }
10141     } else {
10142         GameListDestroy();
10143         if (fseek(f, 0, 0) == -1) {
10144             if (f == lastLoadGameFP ?
10145                 gameNumber == lastLoadGameNumber + 1 :
10146                 gameNumber == 1) {
10147                 gn = 1;
10148             } else {
10149                 DisplayError(_("Can't seek on game file"), 0);
10150                 return FALSE;
10151             }
10152         }
10153     }
10154     lastLoadGameFP = f;
10155     lastLoadGameNumber = gameNumber;
10156     safeStrCpy(lastLoadGameTitle, title, sizeof(lastLoadGameTitle)/sizeof(lastLoadGameTitle[0]));
10157     lastLoadGameUseList = useList;
10158
10159     yynewfile(f);
10160
10161     if (lg && lg->gameInfo.white && lg->gameInfo.black) {
10162       snprintf(buf, sizeof(buf), "%s vs. %s", lg->gameInfo.white,
10163                 lg->gameInfo.black);
10164             DisplayTitle(buf);
10165     } else if (*title != NULLCHAR) {
10166         if (gameNumber > 1) {
10167           snprintf(buf, MSG_SIZ, "%s %d", title, gameNumber);
10168             DisplayTitle(buf);
10169         } else {
10170             DisplayTitle(title);
10171         }
10172     }
10173
10174     if (gameMode != AnalyzeFile && gameMode != AnalyzeMode) {
10175         gameMode = PlayFromGameFile;
10176         ModeHighlight();
10177     }
10178
10179     currentMove = forwardMostMove = backwardMostMove = 0;
10180     CopyBoard(boards[0], initialPosition);
10181     StopClocks();
10182
10183     /*
10184      * Skip the first gn-1 games in the file.
10185      * Also skip over anything that precedes an identifiable
10186      * start of game marker, to avoid being confused by
10187      * garbage at the start of the file.  Currently
10188      * recognized start of game markers are the move number "1",
10189      * the pattern "gnuchess .* game", the pattern
10190      * "^[#;%] [^ ]* game file", and a PGN tag block.
10191      * A game that starts with one of the latter two patterns
10192      * will also have a move number 1, possibly
10193      * following a position diagram.
10194      * 5-4-02: Let's try being more lenient and allowing a game to
10195      * start with an unnumbered move.  Does that break anything?
10196      */
10197     cm = lastLoadGameStart = EndOfFile;
10198     while (gn > 0) {
10199         yyboardindex = forwardMostMove;
10200         cm = (ChessMove) Myylex();
10201         switch (cm) {
10202           case EndOfFile:
10203             if (cmailMsgLoaded) {
10204                 nCmailGames = CMAIL_MAX_GAMES - gn;
10205             } else {
10206                 Reset(TRUE, TRUE);
10207                 DisplayError(_("Game not found in file"), 0);
10208             }
10209             return FALSE;
10210
10211           case GNUChessGame:
10212           case XBoardGame:
10213             gn--;
10214             lastLoadGameStart = cm;
10215             break;
10216
10217           case MoveNumberOne:
10218             switch (lastLoadGameStart) {
10219               case GNUChessGame:
10220               case XBoardGame:
10221               case PGNTag:
10222                 break;
10223               case MoveNumberOne:
10224               case EndOfFile:
10225                 gn--;           /* count this game */
10226                 lastLoadGameStart = cm;
10227                 break;
10228               default:
10229                 /* impossible */
10230                 break;
10231             }
10232             break;
10233
10234           case PGNTag:
10235             switch (lastLoadGameStart) {
10236               case GNUChessGame:
10237               case PGNTag:
10238               case MoveNumberOne:
10239               case EndOfFile:
10240                 gn--;           /* count this game */
10241                 lastLoadGameStart = cm;
10242                 break;
10243               case XBoardGame:
10244                 lastLoadGameStart = cm; /* game counted already */
10245                 break;
10246               default:
10247                 /* impossible */
10248                 break;
10249             }
10250             if (gn > 0) {
10251                 do {
10252                     yyboardindex = forwardMostMove;
10253                     cm = (ChessMove) Myylex();
10254                 } while (cm == PGNTag || cm == Comment);
10255             }
10256             break;
10257
10258           case WhiteWins:
10259           case BlackWins:
10260           case GameIsDrawn:
10261             if (cmailMsgLoaded && (CMAIL_MAX_GAMES == lastLoadGameNumber)) {
10262                 if (   cmailResult[CMAIL_MAX_GAMES - gn - 1]
10263                     != CMAIL_OLD_RESULT) {
10264                     nCmailResults ++ ;
10265                     cmailResult[  CMAIL_MAX_GAMES
10266                                 - gn - 1] = CMAIL_OLD_RESULT;
10267                 }
10268             }
10269             break;
10270
10271           case NormalMove:
10272             /* Only a NormalMove can be at the start of a game
10273              * without a position diagram. */
10274             if (lastLoadGameStart == EndOfFile ) {
10275               gn--;
10276               lastLoadGameStart = MoveNumberOne;
10277             }
10278             break;
10279
10280           default:
10281             break;
10282         }
10283     }
10284
10285     if (appData.debugMode)
10286       fprintf(debugFP, "Parsed game start '%s' (%d)\n", yy_text, (int) cm);
10287
10288     if (cm == XBoardGame) {
10289         /* Skip any header junk before position diagram and/or move 1 */
10290         for (;;) {
10291             yyboardindex = forwardMostMove;
10292             cm = (ChessMove) Myylex();
10293
10294             if (cm == EndOfFile ||
10295                 cm == GNUChessGame || cm == XBoardGame) {
10296                 /* Empty game; pretend end-of-file and handle later */
10297                 cm = EndOfFile;
10298                 break;
10299             }
10300
10301             if (cm == MoveNumberOne || cm == PositionDiagram ||
10302                 cm == PGNTag || cm == Comment)
10303               break;
10304         }
10305     } else if (cm == GNUChessGame) {
10306         if (gameInfo.event != NULL) {
10307             free(gameInfo.event);
10308         }
10309         gameInfo.event = StrSave(yy_text);
10310     }
10311
10312     startedFromSetupPosition = FALSE;
10313     while (cm == PGNTag) {
10314         if (appData.debugMode)
10315           fprintf(debugFP, "Parsed PGNTag: %s\n", yy_text);
10316         err = ParsePGNTag(yy_text, &gameInfo);
10317         if (!err) numPGNTags++;
10318
10319         /* [HGM] PGNvariant: automatically switch to variant given in PGN tag */
10320         if(gameInfo.variant != oldVariant) {
10321             startedFromPositionFile = FALSE; /* [HGM] loadPos: variant switch likely makes position invalid */
10322             ResetFrontEnd(); // [HGM] might need other bitmaps. Cannot use Reset() because it clears gameInfo :-(
10323             InitPosition(TRUE);
10324             oldVariant = gameInfo.variant;
10325             if (appData.debugMode)
10326               fprintf(debugFP, "New variant %d\n", (int) oldVariant);
10327         }
10328
10329
10330         if (gameInfo.fen != NULL) {
10331           Board initial_position;
10332           startedFromSetupPosition = TRUE;
10333           if (!ParseFEN(initial_position, &blackPlaysFirst, gameInfo.fen)) {
10334             Reset(TRUE, TRUE);
10335             DisplayError(_("Bad FEN position in file"), 0);
10336             return FALSE;
10337           }
10338           CopyBoard(boards[0], initial_position);
10339           if (blackPlaysFirst) {
10340             currentMove = forwardMostMove = backwardMostMove = 1;
10341             CopyBoard(boards[1], initial_position);
10342             safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
10343             safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
10344             timeRemaining[0][1] = whiteTimeRemaining;
10345             timeRemaining[1][1] = blackTimeRemaining;
10346             if (commentList[0] != NULL) {
10347               commentList[1] = commentList[0];
10348               commentList[0] = NULL;
10349             }
10350           } else {
10351             currentMove = forwardMostMove = backwardMostMove = 0;
10352           }
10353           /* [HGM] copy FEN attributes as well. Bugfix 4.3.14m and 4.3.15e: moved to after 'blackPlaysFirst' */
10354           {   int i;
10355               initialRulePlies = FENrulePlies;
10356               for( i=0; i< nrCastlingRights; i++ )
10357                   initialRights[i] = initial_position[CASTLING][i];
10358           }
10359           yyboardindex = forwardMostMove;
10360           free(gameInfo.fen);
10361           gameInfo.fen = NULL;
10362         }
10363
10364         yyboardindex = forwardMostMove;
10365         cm = (ChessMove) Myylex();
10366
10367         /* Handle comments interspersed among the tags */
10368         while (cm == Comment) {
10369             char *p;
10370             if (appData.debugMode)
10371               fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
10372             p = yy_text;
10373             AppendComment(currentMove, p, FALSE);
10374             yyboardindex = forwardMostMove;
10375             cm = (ChessMove) Myylex();
10376         }
10377     }
10378
10379     /* don't rely on existence of Event tag since if game was
10380      * pasted from clipboard the Event tag may not exist
10381      */
10382     if (numPGNTags > 0){
10383         char *tags;
10384         if (gameInfo.variant == VariantNormal) {
10385           VariantClass v = StringToVariant(gameInfo.event);
10386           // [HGM] do not recognize variants from event tag that were introduced after supporting variant tag
10387           if(v < VariantShogi) gameInfo.variant = v;
10388         }
10389         if (!matchMode) {
10390           if( appData.autoDisplayTags ) {
10391             tags = PGNTags(&gameInfo);
10392             TagsPopUp(tags, CmailMsg());
10393             free(tags);
10394           }
10395         }
10396     } else {
10397         /* Make something up, but don't display it now */
10398         SetGameInfo();
10399         TagsPopDown();
10400     }
10401
10402     if (cm == PositionDiagram) {
10403         int i, j;
10404         char *p;
10405         Board initial_position;
10406
10407         if (appData.debugMode)
10408           fprintf(debugFP, "Parsed PositionDiagram: %s\n", yy_text);
10409
10410         if (!startedFromSetupPosition) {
10411             p = yy_text;
10412             for (i = BOARD_HEIGHT - 1; i >= 0; i--)
10413               for (j = BOARD_LEFT; j < BOARD_RGHT; p++)
10414                 switch (*p) {
10415                   case '[':
10416                   case '-':
10417                   case ' ':
10418                   case '\t':
10419                   case '\n':
10420                   case '\r':
10421                     break;
10422                   default:
10423                     initial_position[i][j++] = CharToPiece(*p);
10424                     break;
10425                 }
10426             while (*p == ' ' || *p == '\t' ||
10427                    *p == '\n' || *p == '\r') p++;
10428
10429             if (strncmp(p, "black", strlen("black"))==0)
10430               blackPlaysFirst = TRUE;
10431             else
10432               blackPlaysFirst = FALSE;
10433             startedFromSetupPosition = TRUE;
10434
10435             CopyBoard(boards[0], initial_position);
10436             if (blackPlaysFirst) {
10437                 currentMove = forwardMostMove = backwardMostMove = 1;
10438                 CopyBoard(boards[1], initial_position);
10439                 safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
10440                 safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
10441                 timeRemaining[0][1] = whiteTimeRemaining;
10442                 timeRemaining[1][1] = blackTimeRemaining;
10443                 if (commentList[0] != NULL) {
10444                     commentList[1] = commentList[0];
10445                     commentList[0] = NULL;
10446                 }
10447             } else {
10448                 currentMove = forwardMostMove = backwardMostMove = 0;
10449             }
10450         }
10451         yyboardindex = forwardMostMove;
10452         cm = (ChessMove) Myylex();
10453     }
10454
10455     if (first.pr == NoProc) {
10456         StartChessProgram(&first);
10457     }
10458     InitChessProgram(&first, FALSE);
10459     SendToProgram("force\n", &first);
10460     if (startedFromSetupPosition) {
10461         SendBoard(&first, forwardMostMove);
10462     if (appData.debugMode) {
10463         fprintf(debugFP, "Load Game\n");
10464     }
10465         DisplayBothClocks();
10466     }
10467
10468     /* [HGM] server: flag to write setup moves in broadcast file as one */
10469     loadFlag = appData.suppressLoadMoves;
10470
10471     while (cm == Comment) {
10472         char *p;
10473         if (appData.debugMode)
10474           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
10475         p = yy_text;
10476         AppendComment(currentMove, p, FALSE);
10477         yyboardindex = forwardMostMove;
10478         cm = (ChessMove) Myylex();
10479     }
10480
10481     if ((cm == EndOfFile && lastLoadGameStart != EndOfFile ) ||
10482         cm == WhiteWins || cm == BlackWins ||
10483         cm == GameIsDrawn || cm == GameUnfinished) {
10484         DisplayMessage("", _("No moves in game"));
10485         if (cmailMsgLoaded) {
10486             if (appData.debugMode)
10487               fprintf(debugFP, "Setting flipView to %d.\n", FALSE);
10488             ClearHighlights();
10489             flipView = FALSE;
10490         }
10491         DrawPosition(FALSE, boards[currentMove]);
10492         DisplayBothClocks();
10493         gameMode = EditGame;
10494         ModeHighlight();
10495         gameFileFP = NULL;
10496         cmailOldMove = 0;
10497         return TRUE;
10498     }
10499
10500     // [HGM] PV info: routine tests if comment empty
10501     if (!matchMode && (pausing || appData.timeDelay != 0)) {
10502         DisplayComment(currentMove - 1, commentList[currentMove]);
10503     }
10504     if (!matchMode && appData.timeDelay != 0)
10505       DrawPosition(FALSE, boards[currentMove]);
10506
10507     if (gameMode == AnalyzeFile || gameMode == AnalyzeMode) {
10508       programStats.ok_to_send = 1;
10509     }
10510
10511     /* if the first token after the PGN tags is a move
10512      * and not move number 1, retrieve it from the parser
10513      */
10514     if (cm != MoveNumberOne)
10515         LoadGameOneMove(cm);
10516
10517     /* load the remaining moves from the file */
10518     while (LoadGameOneMove(EndOfFile)) {
10519       timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
10520       timeRemaining[1][forwardMostMove] = blackTimeRemaining;
10521     }
10522
10523     /* rewind to the start of the game */
10524     currentMove = backwardMostMove;
10525
10526     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
10527
10528     if (oldGameMode == AnalyzeFile ||
10529         oldGameMode == AnalyzeMode) {
10530       AnalyzeFileEvent();
10531     }
10532
10533     if (matchMode || appData.timeDelay == 0) {
10534       ToEndEvent();
10535       gameMode = EditGame;
10536       ModeHighlight();
10537     } else if (appData.timeDelay > 0) {
10538       AutoPlayGameLoop();
10539     }
10540
10541     if (appData.debugMode)
10542         fprintf(debugFP, "LoadGame(): on exit, gameMode %d\n", gameMode);
10543
10544     loadFlag = 0; /* [HGM] true game starts */
10545     return TRUE;
10546 }
10547
10548 /* Support for LoadNextPosition, LoadPreviousPosition, ReloadSamePosition */
10549 int
10550 ReloadPosition(offset)
10551      int offset;
10552 {
10553     int positionNumber = lastLoadPositionNumber + offset;
10554     if (lastLoadPositionFP == NULL) {
10555         DisplayError(_("No position has been loaded yet"), 0);
10556         return FALSE;
10557     }
10558     if (positionNumber <= 0) {
10559         DisplayError(_("Can't back up any further"), 0);
10560         return FALSE;
10561     }
10562     return LoadPosition(lastLoadPositionFP, positionNumber,
10563                         lastLoadPositionTitle);
10564 }
10565
10566 /* Load the nth position from the given file */
10567 int
10568 LoadPositionFromFile(filename, n, title)
10569      char *filename;
10570      int n;
10571      char *title;
10572 {
10573     FILE *f;
10574     char buf[MSG_SIZ];
10575
10576     if (strcmp(filename, "-") == 0) {
10577         return LoadPosition(stdin, n, "stdin");
10578     } else {
10579         f = fopen(filename, "rb");
10580         if (f == NULL) {
10581             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
10582             DisplayError(buf, errno);
10583             return FALSE;
10584         } else {
10585             return LoadPosition(f, n, title);
10586         }
10587     }
10588 }
10589
10590 /* Load the nth position from the given open file, and close it */
10591 int
10592 LoadPosition(f, positionNumber, title)
10593      FILE *f;
10594      int positionNumber;
10595      char *title;
10596 {
10597     char *p, line[MSG_SIZ];
10598     Board initial_position;
10599     int i, j, fenMode, pn;
10600
10601     if (gameMode == Training )
10602         SetTrainingModeOff();
10603
10604     if (gameMode != BeginningOfGame) {
10605         Reset(FALSE, TRUE);
10606     }
10607     if (lastLoadPositionFP != NULL && lastLoadPositionFP != f) {
10608         fclose(lastLoadPositionFP);
10609     }
10610     if (positionNumber == 0) positionNumber = 1;
10611     lastLoadPositionFP = f;
10612     lastLoadPositionNumber = positionNumber;
10613     safeStrCpy(lastLoadPositionTitle, title, sizeof(lastLoadPositionTitle)/sizeof(lastLoadPositionTitle[0]));
10614     if (first.pr == NoProc) {
10615       StartChessProgram(&first);
10616       InitChessProgram(&first, FALSE);
10617     }
10618     pn = positionNumber;
10619     if (positionNumber < 0) {
10620         /* Negative position number means to seek to that byte offset */
10621         if (fseek(f, -positionNumber, 0) == -1) {
10622             DisplayError(_("Can't seek on position file"), 0);
10623             return FALSE;
10624         };
10625         pn = 1;
10626     } else {
10627         if (fseek(f, 0, 0) == -1) {
10628             if (f == lastLoadPositionFP ?
10629                 positionNumber == lastLoadPositionNumber + 1 :
10630                 positionNumber == 1) {
10631                 pn = 1;
10632             } else {
10633                 DisplayError(_("Can't seek on position file"), 0);
10634                 return FALSE;
10635             }
10636         }
10637     }
10638     /* See if this file is FEN or old-style xboard */
10639     if (fgets(line, MSG_SIZ, f) == NULL) {
10640         DisplayError(_("Position not found in file"), 0);
10641         return FALSE;
10642     }
10643     // [HGM] FEN can begin with digit, any piece letter valid in this variant, or a + for Shogi promoted pieces
10644     fenMode = line[0] >= '0' && line[0] <= '9' || line[0] == '+' || CharToPiece(line[0]) != EmptySquare;
10645
10646     if (pn >= 2) {
10647         if (fenMode || line[0] == '#') pn--;
10648         while (pn > 0) {
10649             /* skip positions before number pn */
10650             if (fgets(line, MSG_SIZ, f) == NULL) {
10651                 Reset(TRUE, TRUE);
10652                 DisplayError(_("Position not found in file"), 0);
10653                 return FALSE;
10654             }
10655             if (fenMode || line[0] == '#') pn--;
10656         }
10657     }
10658
10659     if (fenMode) {
10660         if (!ParseFEN(initial_position, &blackPlaysFirst, line)) {
10661             DisplayError(_("Bad FEN position in file"), 0);
10662             return FALSE;
10663         }
10664     } else {
10665         (void) fgets(line, MSG_SIZ, f);
10666         (void) fgets(line, MSG_SIZ, f);
10667
10668         for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
10669             (void) fgets(line, MSG_SIZ, f);
10670             for (p = line, j = BOARD_LEFT; j < BOARD_RGHT; p++) {
10671                 if (*p == ' ')
10672                   continue;
10673                 initial_position[i][j++] = CharToPiece(*p);
10674             }
10675         }
10676
10677         blackPlaysFirst = FALSE;
10678         if (!feof(f)) {
10679             (void) fgets(line, MSG_SIZ, f);
10680             if (strncmp(line, "black", strlen("black"))==0)
10681               blackPlaysFirst = TRUE;
10682         }
10683     }
10684     startedFromSetupPosition = TRUE;
10685
10686     SendToProgram("force\n", &first);
10687     CopyBoard(boards[0], initial_position);
10688     if (blackPlaysFirst) {
10689         currentMove = forwardMostMove = backwardMostMove = 1;
10690         safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
10691         safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
10692         CopyBoard(boards[1], initial_position);
10693         DisplayMessage("", _("Black to play"));
10694     } else {
10695         currentMove = forwardMostMove = backwardMostMove = 0;
10696         DisplayMessage("", _("White to play"));
10697     }
10698     initialRulePlies = FENrulePlies; /* [HGM] copy FEN attributes as well */
10699     SendBoard(&first, forwardMostMove);
10700     if (appData.debugMode) {
10701 int i, j;
10702   for(i=0;i<2;i++){for(j=0;j<6;j++)fprintf(debugFP, " %d", boards[i][CASTLING][j]);fprintf(debugFP,"\n");}
10703   for(j=0;j<6;j++)fprintf(debugFP, " %d", initialRights[j]);fprintf(debugFP,"\n");
10704         fprintf(debugFP, "Load Position\n");
10705     }
10706
10707     if (positionNumber > 1) {
10708       snprintf(line, MSG_SIZ, "%s %d", title, positionNumber);
10709         DisplayTitle(line);
10710     } else {
10711         DisplayTitle(title);
10712     }
10713     gameMode = EditGame;
10714     ModeHighlight();
10715     ResetClocks();
10716     timeRemaining[0][1] = whiteTimeRemaining;
10717     timeRemaining[1][1] = blackTimeRemaining;
10718     DrawPosition(FALSE, boards[currentMove]);
10719
10720     return TRUE;
10721 }
10722
10723
10724 void
10725 CopyPlayerNameIntoFileName(dest, src)
10726      char **dest, *src;
10727 {
10728     while (*src != NULLCHAR && *src != ',') {
10729         if (*src == ' ') {
10730             *(*dest)++ = '_';
10731             src++;
10732         } else {
10733             *(*dest)++ = *src++;
10734         }
10735     }
10736 }
10737
10738 char *DefaultFileName(ext)
10739      char *ext;
10740 {
10741     static char def[MSG_SIZ];
10742     char *p;
10743
10744     if (gameInfo.white != NULL && gameInfo.white[0] != '-') {
10745         p = def;
10746         CopyPlayerNameIntoFileName(&p, gameInfo.white);
10747         *p++ = '-';
10748         CopyPlayerNameIntoFileName(&p, gameInfo.black);
10749         *p++ = '.';
10750         safeStrCpy(p, ext, MSG_SIZ-2-strlen(gameInfo.white)-strlen(gameInfo.black));
10751     } else {
10752         def[0] = NULLCHAR;
10753     }
10754     return def;
10755 }
10756
10757 /* Save the current game to the given file */
10758 int
10759 SaveGameToFile(filename, append)
10760      char *filename;
10761      int append;
10762 {
10763     FILE *f;
10764     char buf[MSG_SIZ];
10765
10766     if (strcmp(filename, "-") == 0) {
10767         return SaveGame(stdout, 0, NULL);
10768     } else {
10769         f = fopen(filename, append ? "a" : "w");
10770         if (f == NULL) {
10771             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
10772             DisplayError(buf, errno);
10773             return FALSE;
10774         } else {
10775             return SaveGame(f, 0, NULL);
10776         }
10777     }
10778 }
10779
10780 char *
10781 SavePart(str)
10782      char *str;
10783 {
10784     static char buf[MSG_SIZ];
10785     char *p;
10786
10787     p = strchr(str, ' ');
10788     if (p == NULL) return str;
10789     strncpy(buf, str, p - str);
10790     buf[p - str] = NULLCHAR;
10791     return buf;
10792 }
10793
10794 #define PGN_MAX_LINE 75
10795
10796 #define PGN_SIDE_WHITE  0
10797 #define PGN_SIDE_BLACK  1
10798
10799 /* [AS] */
10800 static int FindFirstMoveOutOfBook( int side )
10801 {
10802     int result = -1;
10803
10804     if( backwardMostMove == 0 && ! startedFromSetupPosition) {
10805         int index = backwardMostMove;
10806         int has_book_hit = 0;
10807
10808         if( (index % 2) != side ) {
10809             index++;
10810         }
10811
10812         while( index < forwardMostMove ) {
10813             /* Check to see if engine is in book */
10814             int depth = pvInfoList[index].depth;
10815             int score = pvInfoList[index].score;
10816             int in_book = 0;
10817
10818             if( depth <= 2 ) {
10819                 in_book = 1;
10820             }
10821             else if( score == 0 && depth == 63 ) {
10822                 in_book = 1; /* Zappa */
10823             }
10824             else if( score == 2 && depth == 99 ) {
10825                 in_book = 1; /* Abrok */
10826             }
10827
10828             has_book_hit += in_book;
10829
10830             if( ! in_book ) {
10831                 result = index;
10832
10833                 break;
10834             }
10835
10836             index += 2;
10837         }
10838     }
10839
10840     return result;
10841 }
10842
10843 /* [AS] */
10844 void GetOutOfBookInfo( char * buf )
10845 {
10846     int oob[2];
10847     int i;
10848     int offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
10849
10850     oob[0] = FindFirstMoveOutOfBook( PGN_SIDE_WHITE );
10851     oob[1] = FindFirstMoveOutOfBook( PGN_SIDE_BLACK );
10852
10853     *buf = '\0';
10854
10855     if( oob[0] >= 0 || oob[1] >= 0 ) {
10856         for( i=0; i<2; i++ ) {
10857             int idx = oob[i];
10858
10859             if( idx >= 0 ) {
10860                 if( i > 0 && oob[0] >= 0 ) {
10861                     strcat( buf, "   " );
10862                 }
10863
10864                 sprintf( buf+strlen(buf), "%d%s. ", (idx - offset)/2 + 1, idx & 1 ? ".." : "" );
10865                 sprintf( buf+strlen(buf), "%s%.2f",
10866                     pvInfoList[idx].score >= 0 ? "+" : "",
10867                     pvInfoList[idx].score / 100.0 );
10868             }
10869         }
10870     }
10871 }
10872
10873 /* Save game in PGN style and close the file */
10874 int
10875 SaveGamePGN(f)
10876      FILE *f;
10877 {
10878     int i, offset, linelen, newblock;
10879     time_t tm;
10880 //    char *movetext;
10881     char numtext[32];
10882     int movelen, numlen, blank;
10883     char move_buffer[100]; /* [AS] Buffer for move+PV info */
10884
10885     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
10886
10887     tm = time((time_t *) NULL);
10888
10889     PrintPGNTags(f, &gameInfo);
10890
10891     if (backwardMostMove > 0 || startedFromSetupPosition) {
10892         char *fen = PositionToFEN(backwardMostMove, NULL);
10893         fprintf(f, "[FEN \"%s\"]\n[SetUp \"1\"]\n", fen);
10894         fprintf(f, "\n{--------------\n");
10895         PrintPosition(f, backwardMostMove);
10896         fprintf(f, "--------------}\n");
10897         free(fen);
10898     }
10899     else {
10900         /* [AS] Out of book annotation */
10901         if( appData.saveOutOfBookInfo ) {
10902             char buf[64];
10903
10904             GetOutOfBookInfo( buf );
10905
10906             if( buf[0] != '\0' ) {
10907                 fprintf( f, "[%s \"%s\"]\n", PGN_OUT_OF_BOOK, buf );
10908             }
10909         }
10910
10911         fprintf(f, "\n");
10912     }
10913
10914     i = backwardMostMove;
10915     linelen = 0;
10916     newblock = TRUE;
10917
10918     while (i < forwardMostMove) {
10919         /* Print comments preceding this move */
10920         if (commentList[i] != NULL) {
10921             if (linelen > 0) fprintf(f, "\n");
10922             fprintf(f, "%s", commentList[i]);
10923             linelen = 0;
10924             newblock = TRUE;
10925         }
10926
10927         /* Format move number */
10928         if ((i % 2) == 0)
10929           snprintf(numtext, sizeof(numtext)/sizeof(numtext[0]),"%d.", (i - offset)/2 + 1);
10930         else
10931           if (newblock)
10932             snprintf(numtext, sizeof(numtext)/sizeof(numtext[0]), "%d...", (i - offset)/2 + 1);
10933           else
10934             numtext[0] = NULLCHAR;
10935
10936         numlen = strlen(numtext);
10937         newblock = FALSE;
10938
10939         /* Print move number */
10940         blank = linelen > 0 && numlen > 0;
10941         if (linelen + (blank ? 1 : 0) + numlen > PGN_MAX_LINE) {
10942             fprintf(f, "\n");
10943             linelen = 0;
10944             blank = 0;
10945         }
10946         if (blank) {
10947             fprintf(f, " ");
10948             linelen++;
10949         }
10950         fprintf(f, "%s", numtext);
10951         linelen += numlen;
10952
10953         /* Get move */
10954         safeStrCpy(move_buffer, SavePart(parseList[i]), sizeof(move_buffer)/sizeof(move_buffer[0])); // [HGM] pgn: print move via buffer, so it can be edited
10955         movelen = strlen(move_buffer); /* [HGM] pgn: line-break point before move */
10956
10957         /* Print move */
10958         blank = linelen > 0 && movelen > 0;
10959         if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
10960             fprintf(f, "\n");
10961             linelen = 0;
10962             blank = 0;
10963         }
10964         if (blank) {
10965             fprintf(f, " ");
10966             linelen++;
10967         }
10968         fprintf(f, "%s", move_buffer);
10969         linelen += movelen;
10970
10971         /* [AS] Add PV info if present */
10972         if( i >= 0 && appData.saveExtendedInfoInPGN && pvInfoList[i].depth > 0 ) {
10973             /* [HGM] add time */
10974             char buf[MSG_SIZ]; int seconds;
10975
10976             seconds = (pvInfoList[i].time+5)/10; // deci-seconds, rounded to nearest
10977
10978             if( seconds <= 0)
10979               buf[0] = 0;
10980             else
10981               if( seconds < 30 )
10982                 snprintf(buf, MSG_SIZ, " %3.1f%c", seconds/10., 0);
10983               else
10984                 {
10985                   seconds = (seconds + 4)/10; // round to full seconds
10986                   if( seconds < 60 )
10987                     snprintf(buf, MSG_SIZ, " %d%c", seconds, 0);
10988                   else
10989                     snprintf(buf, MSG_SIZ, " %d:%02d%c", seconds/60, seconds%60, 0);
10990                 }
10991
10992             snprintf( move_buffer, sizeof(move_buffer)/sizeof(move_buffer[0]),"{%s%.2f/%d%s}",
10993                       pvInfoList[i].score >= 0 ? "+" : "",
10994                       pvInfoList[i].score / 100.0,
10995                       pvInfoList[i].depth,
10996                       buf );
10997
10998             movelen = strlen(move_buffer); /* [HGM] pgn: line-break point after move */
10999
11000             /* Print score/depth */
11001             blank = linelen > 0 && movelen > 0;
11002             if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
11003                 fprintf(f, "\n");
11004                 linelen = 0;
11005                 blank = 0;
11006             }
11007             if (blank) {
11008                 fprintf(f, " ");
11009                 linelen++;
11010             }
11011             fprintf(f, "%s", move_buffer);
11012             linelen += movelen;
11013         }
11014
11015         i++;
11016     }
11017
11018     /* Start a new line */
11019     if (linelen > 0) fprintf(f, "\n");
11020
11021     /* Print comments after last move */
11022     if (commentList[i] != NULL) {
11023         fprintf(f, "%s\n", commentList[i]);
11024     }
11025
11026     /* Print result */
11027     if (gameInfo.resultDetails != NULL &&
11028         gameInfo.resultDetails[0] != NULLCHAR) {
11029         fprintf(f, "{%s} %s\n\n", gameInfo.resultDetails,
11030                 PGNResult(gameInfo.result));
11031     } else {
11032         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
11033     }
11034
11035     fclose(f);
11036     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
11037     return TRUE;
11038 }
11039
11040 /* Save game in old style and close the file */
11041 int
11042 SaveGameOldStyle(f)
11043      FILE *f;
11044 {
11045     int i, offset;
11046     time_t tm;
11047
11048     tm = time((time_t *) NULL);
11049
11050     fprintf(f, "# %s game file -- %s", programName, ctime(&tm));
11051     PrintOpponents(f);
11052
11053     if (backwardMostMove > 0 || startedFromSetupPosition) {
11054         fprintf(f, "\n[--------------\n");
11055         PrintPosition(f, backwardMostMove);
11056         fprintf(f, "--------------]\n");
11057     } else {
11058         fprintf(f, "\n");
11059     }
11060
11061     i = backwardMostMove;
11062     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
11063
11064     while (i < forwardMostMove) {
11065         if (commentList[i] != NULL) {
11066             fprintf(f, "[%s]\n", commentList[i]);
11067         }
11068
11069         if ((i % 2) == 1) {
11070             fprintf(f, "%d. ...  %s\n", (i - offset)/2 + 1, parseList[i]);
11071             i++;
11072         } else {
11073             fprintf(f, "%d. %s  ", (i - offset)/2 + 1, parseList[i]);
11074             i++;
11075             if (commentList[i] != NULL) {
11076                 fprintf(f, "\n");
11077                 continue;
11078             }
11079             if (i >= forwardMostMove) {
11080                 fprintf(f, "\n");
11081                 break;
11082             }
11083             fprintf(f, "%s\n", parseList[i]);
11084             i++;
11085         }
11086     }
11087
11088     if (commentList[i] != NULL) {
11089         fprintf(f, "[%s]\n", commentList[i]);
11090     }
11091
11092     /* This isn't really the old style, but it's close enough */
11093     if (gameInfo.resultDetails != NULL &&
11094         gameInfo.resultDetails[0] != NULLCHAR) {
11095         fprintf(f, "%s (%s)\n\n", PGNResult(gameInfo.result),
11096                 gameInfo.resultDetails);
11097     } else {
11098         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
11099     }
11100
11101     fclose(f);
11102     return TRUE;
11103 }
11104
11105 /* Save the current game to open file f and close the file */
11106 int
11107 SaveGame(f, dummy, dummy2)
11108      FILE *f;
11109      int dummy;
11110      char *dummy2;
11111 {
11112     if (gameMode == EditPosition) EditPositionDone(TRUE);
11113     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
11114     if (appData.oldSaveStyle)
11115       return SaveGameOldStyle(f);
11116     else
11117       return SaveGamePGN(f);
11118 }
11119
11120 /* Save the current position to the given file */
11121 int
11122 SavePositionToFile(filename)
11123      char *filename;
11124 {
11125     FILE *f;
11126     char buf[MSG_SIZ];
11127
11128     if (strcmp(filename, "-") == 0) {
11129         return SavePosition(stdout, 0, NULL);
11130     } else {
11131         f = fopen(filename, "a");
11132         if (f == NULL) {
11133             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
11134             DisplayError(buf, errno);
11135             return FALSE;
11136         } else {
11137             SavePosition(f, 0, NULL);
11138             return TRUE;
11139         }
11140     }
11141 }
11142
11143 /* Save the current position to the given open file and close the file */
11144 int
11145 SavePosition(f, dummy, dummy2)
11146      FILE *f;
11147      int dummy;
11148      char *dummy2;
11149 {
11150     time_t tm;
11151     char *fen;
11152
11153     if (gameMode == EditPosition) EditPositionDone(TRUE);
11154     if (appData.oldSaveStyle) {
11155         tm = time((time_t *) NULL);
11156
11157         fprintf(f, "# %s position file -- %s", programName, ctime(&tm));
11158         PrintOpponents(f);
11159         fprintf(f, "[--------------\n");
11160         PrintPosition(f, currentMove);
11161         fprintf(f, "--------------]\n");
11162     } else {
11163         fen = PositionToFEN(currentMove, NULL);
11164         fprintf(f, "%s\n", fen);
11165         free(fen);
11166     }
11167     fclose(f);
11168     return TRUE;
11169 }
11170
11171 void
11172 ReloadCmailMsgEvent(unregister)
11173      int unregister;
11174 {
11175 #if !WIN32
11176     static char *inFilename = NULL;
11177     static char *outFilename;
11178     int i;
11179     struct stat inbuf, outbuf;
11180     int status;
11181
11182     /* Any registered moves are unregistered if unregister is set, */
11183     /* i.e. invoked by the signal handler */
11184     if (unregister) {
11185         for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
11186             cmailMoveRegistered[i] = FALSE;
11187             if (cmailCommentList[i] != NULL) {
11188                 free(cmailCommentList[i]);
11189                 cmailCommentList[i] = NULL;
11190             }
11191         }
11192         nCmailMovesRegistered = 0;
11193     }
11194
11195     for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
11196         cmailResult[i] = CMAIL_NOT_RESULT;
11197     }
11198     nCmailResults = 0;
11199
11200     if (inFilename == NULL) {
11201         /* Because the filenames are static they only get malloced once  */
11202         /* and they never get freed                                      */
11203         inFilename = (char *) malloc(strlen(appData.cmailGameName) + 9);
11204         sprintf(inFilename, "%s.game.in", appData.cmailGameName);
11205
11206         outFilename = (char *) malloc(strlen(appData.cmailGameName) + 5);
11207         sprintf(outFilename, "%s.out", appData.cmailGameName);
11208     }
11209
11210     status = stat(outFilename, &outbuf);
11211     if (status < 0) {
11212         cmailMailedMove = FALSE;
11213     } else {
11214         status = stat(inFilename, &inbuf);
11215         cmailMailedMove = (inbuf.st_mtime < outbuf.st_mtime);
11216     }
11217
11218     /* LoadGameFromFile(CMAIL_MAX_GAMES) with cmailMsgLoaded == TRUE
11219        counts the games, notes how each one terminated, etc.
11220
11221        It would be nice to remove this kludge and instead gather all
11222        the information while building the game list.  (And to keep it
11223        in the game list nodes instead of having a bunch of fixed-size
11224        parallel arrays.)  Note this will require getting each game's
11225        termination from the PGN tags, as the game list builder does
11226        not process the game moves.  --mann
11227        */
11228     cmailMsgLoaded = TRUE;
11229     LoadGameFromFile(inFilename, CMAIL_MAX_GAMES, "", FALSE);
11230
11231     /* Load first game in the file or popup game menu */
11232     LoadGameFromFile(inFilename, 0, appData.cmailGameName, TRUE);
11233
11234 #endif /* !WIN32 */
11235     return;
11236 }
11237
11238 int
11239 RegisterMove()
11240 {
11241     FILE *f;
11242     char string[MSG_SIZ];
11243
11244     if (   cmailMailedMove
11245         || (cmailResult[lastLoadGameNumber - 1] == CMAIL_OLD_RESULT)) {
11246         return TRUE;            /* Allow free viewing  */
11247     }
11248
11249     /* Unregister move to ensure that we don't leave RegisterMove        */
11250     /* with the move registered when the conditions for registering no   */
11251     /* longer hold                                                       */
11252     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
11253         cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
11254         nCmailMovesRegistered --;
11255
11256         if (cmailCommentList[lastLoadGameNumber - 1] != NULL)
11257           {
11258               free(cmailCommentList[lastLoadGameNumber - 1]);
11259               cmailCommentList[lastLoadGameNumber - 1] = NULL;
11260           }
11261     }
11262
11263     if (cmailOldMove == -1) {
11264         DisplayError(_("You have edited the game history.\nUse Reload Same Game and make your move again."), 0);
11265         return FALSE;
11266     }
11267
11268     if (currentMove > cmailOldMove + 1) {
11269         DisplayError(_("You have entered too many moves.\nBack up to the correct position and try again."), 0);
11270         return FALSE;
11271     }
11272
11273     if (currentMove < cmailOldMove) {
11274         DisplayError(_("Displayed position is not current.\nStep forward to the correct position and try again."), 0);
11275         return FALSE;
11276     }
11277
11278     if (forwardMostMove > currentMove) {
11279         /* Silently truncate extra moves */
11280         TruncateGame();
11281     }
11282
11283     if (   (currentMove == cmailOldMove + 1)
11284         || (   (currentMove == cmailOldMove)
11285             && (   (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_ACCEPT)
11286                 || (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_RESIGN)))) {
11287         if (gameInfo.result != GameUnfinished) {
11288             cmailResult[lastLoadGameNumber - 1] = CMAIL_NEW_RESULT;
11289         }
11290
11291         if (commentList[currentMove] != NULL) {
11292             cmailCommentList[lastLoadGameNumber - 1]
11293               = StrSave(commentList[currentMove]);
11294         }
11295         safeStrCpy(cmailMove[lastLoadGameNumber - 1], moveList[currentMove - 1], sizeof(cmailMove[lastLoadGameNumber - 1])/sizeof(cmailMove[lastLoadGameNumber - 1][0]));
11296
11297         if (appData.debugMode)
11298           fprintf(debugFP, "Saving %s for game %d\n",
11299                   cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
11300
11301         snprintf(string, MSG_SIZ, "%s.game.out.%d", appData.cmailGameName, lastLoadGameNumber);
11302
11303         f = fopen(string, "w");
11304         if (appData.oldSaveStyle) {
11305             SaveGameOldStyle(f); /* also closes the file */
11306
11307             snprintf(string, MSG_SIZ, "%s.pos.out", appData.cmailGameName);
11308             f = fopen(string, "w");
11309             SavePosition(f, 0, NULL); /* also closes the file */
11310         } else {
11311             fprintf(f, "{--------------\n");
11312             PrintPosition(f, currentMove);
11313             fprintf(f, "--------------}\n\n");
11314
11315             SaveGame(f, 0, NULL); /* also closes the file*/
11316         }
11317
11318         cmailMoveRegistered[lastLoadGameNumber - 1] = TRUE;
11319         nCmailMovesRegistered ++;
11320     } else if (nCmailGames == 1) {
11321         DisplayError(_("You have not made a move yet"), 0);
11322         return FALSE;
11323     }
11324
11325     return TRUE;
11326 }
11327
11328 void
11329 MailMoveEvent()
11330 {
11331 #if !WIN32
11332     static char *partCommandString = "cmail -xv%s -remail -game %s 2>&1";
11333     FILE *commandOutput;
11334     char buffer[MSG_SIZ], msg[MSG_SIZ], string[MSG_SIZ];
11335     int nBytes = 0;             /*  Suppress warnings on uninitialized variables    */
11336     int nBuffers;
11337     int i;
11338     int archived;
11339     char *arcDir;
11340
11341     if (! cmailMsgLoaded) {
11342         DisplayError(_("The cmail message is not loaded.\nUse Reload CMail Message and make your move again."), 0);
11343         return;
11344     }
11345
11346     if (nCmailGames == nCmailResults) {
11347         DisplayError(_("No unfinished games"), 0);
11348         return;
11349     }
11350
11351 #if CMAIL_PROHIBIT_REMAIL
11352     if (cmailMailedMove) {
11353       snprintf(msg, MSG_SIZ, _("You have already mailed a move.\nWait until a move arrives from your opponent.\nTo resend the same move, type\n\"cmail -remail -game %s\"\non the command line."), appData.cmailGameName);
11354         DisplayError(msg, 0);
11355         return;
11356     }
11357 #endif
11358
11359     if (! (cmailMailedMove || RegisterMove())) return;
11360
11361     if (   cmailMailedMove
11362         || (nCmailMovesRegistered + nCmailResults == nCmailGames)) {
11363       snprintf(string, MSG_SIZ, partCommandString,
11364                appData.debugMode ? " -v" : "", appData.cmailGameName);
11365         commandOutput = popen(string, "r");
11366
11367         if (commandOutput == NULL) {
11368             DisplayError(_("Failed to invoke cmail"), 0);
11369         } else {
11370             for (nBuffers = 0; (! feof(commandOutput)); nBuffers ++) {
11371                 nBytes = fread(buffer, 1, MSG_SIZ - 1, commandOutput);
11372             }
11373             if (nBuffers > 1) {
11374                 (void) memcpy(msg, buffer + nBytes, MSG_SIZ - nBytes - 1);
11375                 (void) memcpy(msg + MSG_SIZ - nBytes - 1, buffer, nBytes);
11376                 nBytes = MSG_SIZ - 1;
11377             } else {
11378                 (void) memcpy(msg, buffer, nBytes);
11379             }
11380             *(msg + nBytes) = '\0'; /* \0 for end-of-string*/
11381
11382             if(StrStr(msg, "Mailed cmail message to ") != NULL) {
11383                 cmailMailedMove = TRUE; /* Prevent >1 moves    */
11384
11385                 archived = TRUE;
11386                 for (i = 0; i < nCmailGames; i ++) {
11387                     if (cmailResult[i] == CMAIL_NOT_RESULT) {
11388                         archived = FALSE;
11389                     }
11390                 }
11391                 if (   archived
11392                     && (   (arcDir = (char *) getenv("CMAIL_ARCDIR"))
11393                         != NULL)) {
11394                   snprintf(buffer, MSG_SIZ, "%s/%s.%s.archive",
11395                            arcDir,
11396                            appData.cmailGameName,
11397                            gameInfo.date);
11398                     LoadGameFromFile(buffer, 1, buffer, FALSE);
11399                     cmailMsgLoaded = FALSE;
11400                 }
11401             }
11402
11403             DisplayInformation(msg);
11404             pclose(commandOutput);
11405         }
11406     } else {
11407         if ((*cmailMsg) != '\0') {
11408             DisplayInformation(cmailMsg);
11409         }
11410     }
11411
11412     return;
11413 #endif /* !WIN32 */
11414 }
11415
11416 char *
11417 CmailMsg()
11418 {
11419 #if WIN32
11420     return NULL;
11421 #else
11422     int  prependComma = 0;
11423     char number[5];
11424     char string[MSG_SIZ];       /* Space for game-list */
11425     int  i;
11426
11427     if (!cmailMsgLoaded) return "";
11428
11429     if (cmailMailedMove) {
11430       snprintf(cmailMsg, MSG_SIZ, _("Waiting for reply from opponent\n"));
11431     } else {
11432         /* Create a list of games left */
11433       snprintf(string, MSG_SIZ, "[");
11434         for (i = 0; i < nCmailGames; i ++) {
11435             if (! (   cmailMoveRegistered[i]
11436                    || (cmailResult[i] == CMAIL_OLD_RESULT))) {
11437                 if (prependComma) {
11438                     snprintf(number, sizeof(number)/sizeof(number[0]), ",%d", i + 1);
11439                 } else {
11440                     snprintf(number, sizeof(number)/sizeof(number[0]), "%d", i + 1);
11441                     prependComma = 1;
11442                 }
11443
11444                 strcat(string, number);
11445             }
11446         }
11447         strcat(string, "]");
11448
11449         if (nCmailMovesRegistered + nCmailResults == 0) {
11450             switch (nCmailGames) {
11451               case 1:
11452                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make move for game\n"));
11453                 break;
11454
11455               case 2:
11456                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make moves for both games\n"));
11457                 break;
11458
11459               default:
11460                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make moves for all %d games\n"),
11461                          nCmailGames);
11462                 break;
11463             }
11464         } else {
11465             switch (nCmailGames - nCmailMovesRegistered - nCmailResults) {
11466               case 1:
11467                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make a move for game %s\n"),
11468                          string);
11469                 break;
11470
11471               case 0:
11472                 if (nCmailResults == nCmailGames) {
11473                   snprintf(cmailMsg, MSG_SIZ, _("No unfinished games\n"));
11474                 } else {
11475                   snprintf(cmailMsg, MSG_SIZ, _("Ready to send mail\n"));
11476                 }
11477                 break;
11478
11479               default:
11480                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make moves for games %s\n"),
11481                          string);
11482             }
11483         }
11484     }
11485     return cmailMsg;
11486 #endif /* WIN32 */
11487 }
11488
11489 void
11490 ResetGameEvent()
11491 {
11492     if (gameMode == Training)
11493       SetTrainingModeOff();
11494
11495     Reset(TRUE, TRUE);
11496     cmailMsgLoaded = FALSE;
11497     if (appData.icsActive) {
11498       SendToICS(ics_prefix);
11499       SendToICS("refresh\n");
11500     }
11501 }
11502
11503 void
11504 ExitEvent(status)
11505      int status;
11506 {
11507     exiting++;
11508     if (exiting > 2) {
11509       /* Give up on clean exit */
11510       exit(status);
11511     }
11512     if (exiting > 1) {
11513       /* Keep trying for clean exit */
11514       return;
11515     }
11516
11517     if (appData.icsActive && appData.colorize) Colorize(ColorNone, FALSE);
11518
11519     if (telnetISR != NULL) {
11520       RemoveInputSource(telnetISR);
11521     }
11522     if (icsPR != NoProc) {
11523       DestroyChildProcess(icsPR, TRUE);
11524     }
11525
11526     /* [HGM] crash: leave writing PGN and position entirely to GameEnds() */
11527     GameEnds(gameInfo.result, gameInfo.resultDetails==NULL ? "xboard exit" : gameInfo.resultDetails, GE_PLAYER);
11528
11529     /* [HGM] crash: the above GameEnds() is a dud if another one was running */
11530     /* make sure this other one finishes before killing it!                  */
11531     if(endingGame) { int count = 0;
11532         if(appData.debugMode) fprintf(debugFP, "ExitEvent() during GameEnds(), wait\n");
11533         while(endingGame && count++ < 10) DoSleep(1);
11534         if(appData.debugMode && endingGame) fprintf(debugFP, "GameEnds() seems stuck, proceed exiting\n");
11535     }
11536
11537     /* Kill off chess programs */
11538     if (first.pr != NoProc) {
11539         ExitAnalyzeMode();
11540
11541         DoSleep( appData.delayBeforeQuit );
11542         SendToProgram("quit\n", &first);
11543         DoSleep( appData.delayAfterQuit );
11544         DestroyChildProcess(first.pr, 10 /* [AS] first.useSigterm */ );
11545     }
11546     if (second.pr != NoProc) {
11547         DoSleep( appData.delayBeforeQuit );
11548         SendToProgram("quit\n", &second);
11549         DoSleep( appData.delayAfterQuit );
11550         DestroyChildProcess(second.pr, 10 /* [AS] second.useSigterm */ );
11551     }
11552     if (first.isr != NULL) {
11553         RemoveInputSource(first.isr);
11554     }
11555     if (second.isr != NULL) {
11556         RemoveInputSource(second.isr);
11557     }
11558
11559     ShutDownFrontEnd();
11560     exit(status);
11561 }
11562
11563 void
11564 PauseEvent()
11565 {
11566     if (appData.debugMode)
11567         fprintf(debugFP, "PauseEvent(): pausing %d\n", pausing);
11568     if (pausing) {
11569         pausing = FALSE;
11570         ModeHighlight();
11571         if (gameMode == MachinePlaysWhite ||
11572             gameMode == MachinePlaysBlack) {
11573             StartClocks();
11574         } else {
11575             DisplayBothClocks();
11576         }
11577         if (gameMode == PlayFromGameFile) {
11578             if (appData.timeDelay >= 0)
11579                 AutoPlayGameLoop();
11580         } else if (gameMode == IcsExamining && pauseExamInvalid) {
11581             Reset(FALSE, TRUE);
11582             SendToICS(ics_prefix);
11583             SendToICS("refresh\n");
11584         } else if (currentMove < forwardMostMove) {
11585             ForwardInner(forwardMostMove);
11586         }
11587         pauseExamInvalid = FALSE;
11588     } else {
11589         switch (gameMode) {
11590           default:
11591             return;
11592           case IcsExamining:
11593             pauseExamForwardMostMove = forwardMostMove;
11594             pauseExamInvalid = FALSE;
11595             /* fall through */
11596           case IcsObserving:
11597           case IcsPlayingWhite:
11598           case IcsPlayingBlack:
11599             pausing = TRUE;
11600             ModeHighlight();
11601             return;
11602           case PlayFromGameFile:
11603             (void) StopLoadGameTimer();
11604             pausing = TRUE;
11605             ModeHighlight();
11606             break;
11607           case BeginningOfGame:
11608             if (appData.icsActive) return;
11609             /* else fall through */
11610           case MachinePlaysWhite:
11611           case MachinePlaysBlack:
11612           case TwoMachinesPlay:
11613             if (forwardMostMove == 0)
11614               return;           /* don't pause if no one has moved */
11615             if ((gameMode == MachinePlaysWhite &&
11616                  !WhiteOnMove(forwardMostMove)) ||
11617                 (gameMode == MachinePlaysBlack &&
11618                  WhiteOnMove(forwardMostMove))) {
11619                 StopClocks();
11620             }
11621             pausing = TRUE;
11622             ModeHighlight();
11623             break;
11624         }
11625     }
11626 }
11627
11628 void
11629 EditCommentEvent()
11630 {
11631     char title[MSG_SIZ];
11632
11633     if (currentMove < 1 || parseList[currentMove - 1][0] == NULLCHAR) {
11634       safeStrCpy(title, _("Edit comment"), sizeof(title)/sizeof(title[0]));
11635     } else {
11636       snprintf(title, MSG_SIZ, _("Edit comment on %d.%s%s"), (currentMove - 1) / 2 + 1,
11637                WhiteOnMove(currentMove - 1) ? " " : ".. ",
11638                parseList[currentMove - 1]);
11639     }
11640
11641     EditCommentPopUp(currentMove, title, commentList[currentMove]);
11642 }
11643
11644
11645 void
11646 EditTagsEvent()
11647 {
11648     char *tags = PGNTags(&gameInfo);
11649     EditTagsPopUp(tags);
11650     free(tags);
11651 }
11652
11653 void
11654 AnalyzeModeEvent()
11655 {
11656     if (appData.noChessProgram || gameMode == AnalyzeMode)
11657       return;
11658
11659     if (gameMode != AnalyzeFile) {
11660         if (!appData.icsEngineAnalyze) {
11661                EditGameEvent();
11662                if (gameMode != EditGame) return;
11663         }
11664         ResurrectChessProgram();
11665         SendToProgram("analyze\n", &first);
11666         first.analyzing = TRUE;
11667         /*first.maybeThinking = TRUE;*/
11668         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
11669         EngineOutputPopUp();
11670     }
11671     if (!appData.icsEngineAnalyze) gameMode = AnalyzeMode;
11672     pausing = FALSE;
11673     ModeHighlight();
11674     SetGameInfo();
11675
11676     StartAnalysisClock();
11677     GetTimeMark(&lastNodeCountTime);
11678     lastNodeCount = 0;
11679 }
11680
11681 void
11682 AnalyzeFileEvent()
11683 {
11684     if (appData.noChessProgram || gameMode == AnalyzeFile)
11685       return;
11686
11687     if (gameMode != AnalyzeMode) {
11688         EditGameEvent();
11689         if (gameMode != EditGame) return;
11690         ResurrectChessProgram();
11691         SendToProgram("analyze\n", &first);
11692         first.analyzing = TRUE;
11693         /*first.maybeThinking = TRUE;*/
11694         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
11695         EngineOutputPopUp();
11696     }
11697     gameMode = AnalyzeFile;
11698     pausing = FALSE;
11699     ModeHighlight();
11700     SetGameInfo();
11701
11702     StartAnalysisClock();
11703     GetTimeMark(&lastNodeCountTime);
11704     lastNodeCount = 0;
11705 }
11706
11707 void
11708 MachineWhiteEvent()
11709 {
11710     char buf[MSG_SIZ];
11711     char *bookHit = NULL;
11712
11713     if (appData.noChessProgram || (gameMode == MachinePlaysWhite))
11714       return;
11715
11716
11717     if (gameMode == PlayFromGameFile ||
11718         gameMode == TwoMachinesPlay  ||
11719         gameMode == Training         ||
11720         gameMode == AnalyzeMode      ||
11721         gameMode == EndOfGame)
11722         EditGameEvent();
11723
11724     if (gameMode == EditPosition)
11725         EditPositionDone(TRUE);
11726
11727     if (!WhiteOnMove(currentMove)) {
11728         DisplayError(_("It is not White's turn"), 0);
11729         return;
11730     }
11731
11732     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
11733       ExitAnalyzeMode();
11734
11735     if (gameMode == EditGame || gameMode == AnalyzeMode ||
11736         gameMode == AnalyzeFile)
11737         TruncateGame();
11738
11739     ResurrectChessProgram();    /* in case it isn't running */
11740     if(gameMode == BeginningOfGame) { /* [HGM] time odds: to get right odds in human mode */
11741         gameMode = MachinePlaysWhite;
11742         ResetClocks();
11743     } else
11744     gameMode = MachinePlaysWhite;
11745     pausing = FALSE;
11746     ModeHighlight();
11747     SetGameInfo();
11748     snprintf(buf, MSG_SIZ, "%s vs. %s", gameInfo.white, gameInfo.black);
11749     DisplayTitle(buf);
11750     if (first.sendName) {
11751       snprintf(buf, MSG_SIZ, "name %s\n", gameInfo.black);
11752       SendToProgram(buf, &first);
11753     }
11754     if (first.sendTime) {
11755       if (first.useColors) {
11756         SendToProgram("black\n", &first); /*gnu kludge*/
11757       }
11758       SendTimeRemaining(&first, TRUE);
11759     }
11760     if (first.useColors) {
11761       SendToProgram("white\n", &first); // [HGM] book: send 'go' separately
11762     }
11763     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
11764     SetMachineThinkingEnables();
11765     first.maybeThinking = TRUE;
11766     StartClocks();
11767     firstMove = FALSE;
11768
11769     if (appData.autoFlipView && !flipView) {
11770       flipView = !flipView;
11771       DrawPosition(FALSE, NULL);
11772       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
11773     }
11774
11775     if(bookHit) { // [HGM] book: simulate book reply
11776         static char bookMove[MSG_SIZ]; // a bit generous?
11777
11778         programStats.nodes = programStats.depth = programStats.time =
11779         programStats.score = programStats.got_only_move = 0;
11780         sprintf(programStats.movelist, "%s (xbook)", bookHit);
11781
11782         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
11783         strcat(bookMove, bookHit);
11784         HandleMachineMove(bookMove, &first);
11785     }
11786 }
11787
11788 void
11789 MachineBlackEvent()
11790 {
11791   char buf[MSG_SIZ];
11792   char *bookHit = NULL;
11793
11794     if (appData.noChessProgram || (gameMode == MachinePlaysBlack))
11795         return;
11796
11797
11798     if (gameMode == PlayFromGameFile ||
11799         gameMode == TwoMachinesPlay  ||
11800         gameMode == Training         ||
11801         gameMode == AnalyzeMode      ||
11802         gameMode == EndOfGame)
11803         EditGameEvent();
11804
11805     if (gameMode == EditPosition)
11806         EditPositionDone(TRUE);
11807
11808     if (WhiteOnMove(currentMove)) {
11809         DisplayError(_("It is not Black's turn"), 0);
11810         return;
11811     }
11812
11813     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
11814       ExitAnalyzeMode();
11815
11816     if (gameMode == EditGame || gameMode == AnalyzeMode ||
11817         gameMode == AnalyzeFile)
11818         TruncateGame();
11819
11820     ResurrectChessProgram();    /* in case it isn't running */
11821     gameMode = MachinePlaysBlack;
11822     pausing = FALSE;
11823     ModeHighlight();
11824     SetGameInfo();
11825     snprintf(buf, MSG_SIZ, "%s vs. %s", gameInfo.white, gameInfo.black);
11826     DisplayTitle(buf);
11827     if (first.sendName) {
11828       snprintf(buf, MSG_SIZ, "name %s\n", gameInfo.white);
11829       SendToProgram(buf, &first);
11830     }
11831     if (first.sendTime) {
11832       if (first.useColors) {
11833         SendToProgram("white\n", &first); /*gnu kludge*/
11834       }
11835       SendTimeRemaining(&first, FALSE);
11836     }
11837     if (first.useColors) {
11838       SendToProgram("black\n", &first); // [HGM] book: 'go' sent separately
11839     }
11840     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
11841     SetMachineThinkingEnables();
11842     first.maybeThinking = TRUE;
11843     StartClocks();
11844
11845     if (appData.autoFlipView && flipView) {
11846       flipView = !flipView;
11847       DrawPosition(FALSE, NULL);
11848       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
11849     }
11850     if(bookHit) { // [HGM] book: simulate book reply
11851         static char bookMove[MSG_SIZ]; // a bit generous?
11852
11853         programStats.nodes = programStats.depth = programStats.time =
11854         programStats.score = programStats.got_only_move = 0;
11855         sprintf(programStats.movelist, "%s (xbook)", bookHit);
11856
11857         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
11858         strcat(bookMove, bookHit);
11859         HandleMachineMove(bookMove, &first);
11860     }
11861 }
11862
11863
11864 void
11865 DisplayTwoMachinesTitle()
11866 {
11867     char buf[MSG_SIZ];
11868     if (appData.matchGames > 0) {
11869         if (first.twoMachinesColor[0] == 'w') {
11870           snprintf(buf, MSG_SIZ, "%s vs. %s (%d-%d-%d)",
11871                    gameInfo.white, gameInfo.black,
11872                    first.matchWins, second.matchWins,
11873                    matchGame - 1 - (first.matchWins + second.matchWins));
11874         } else {
11875           snprintf(buf, MSG_SIZ, "%s vs. %s (%d-%d-%d)",
11876                    gameInfo.white, gameInfo.black,
11877                    second.matchWins, first.matchWins,
11878                    matchGame - 1 - (first.matchWins + second.matchWins));
11879         }
11880     } else {
11881       snprintf(buf, MSG_SIZ, "%s vs. %s", gameInfo.white, gameInfo.black);
11882     }
11883     DisplayTitle(buf);
11884 }
11885
11886 void
11887 SettingsMenuIfReady()
11888 {
11889   if (second.lastPing != second.lastPong) {
11890     DisplayMessage("", _("Waiting for second chess program"));
11891     ScheduleDelayedEvent(SettingsMenuIfReady, 10); // [HGM] fast: lowered from 1000
11892     return;
11893   }
11894   ThawUI();
11895   DisplayMessage("", "");
11896   SettingsPopUp(&second);
11897 }
11898
11899 int
11900 WaitForSecond(DelayedEventCallback retry)
11901 {
11902     if (second.pr == NULL) {
11903         StartChessProgram(&second);
11904         if (second.protocolVersion == 1) {
11905           retry();
11906         } else {
11907           /* kludge: allow timeout for initial "feature" command */
11908           FreezeUI();
11909           DisplayMessage("", _("Starting second chess program"));
11910           ScheduleDelayedEvent(retry, FEATURE_TIMEOUT);
11911         }
11912         return 1;
11913     }
11914     return 0;
11915 }
11916
11917 void
11918 TwoMachinesEvent P((void))
11919 {
11920     int i;
11921     char buf[MSG_SIZ];
11922     ChessProgramState *onmove;
11923     char *bookHit = NULL;
11924
11925     if (appData.noChessProgram) return;
11926
11927     switch (gameMode) {
11928       case TwoMachinesPlay:
11929         return;
11930       case MachinePlaysWhite:
11931       case MachinePlaysBlack:
11932         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
11933             DisplayError(_("Wait until your turn,\nor select Move Now"), 0);
11934             return;
11935         }
11936         /* fall through */
11937       case BeginningOfGame:
11938       case PlayFromGameFile:
11939       case EndOfGame:
11940         EditGameEvent();
11941         if (gameMode != EditGame) return;
11942         break;
11943       case EditPosition:
11944         EditPositionDone(TRUE);
11945         break;
11946       case AnalyzeMode:
11947       case AnalyzeFile:
11948         ExitAnalyzeMode();
11949         break;
11950       case EditGame:
11951       default:
11952         break;
11953     }
11954
11955 //    forwardMostMove = currentMove;
11956     TruncateGame(); // [HGM] vari: MachineWhite and MachineBlack do this...
11957     ResurrectChessProgram();    /* in case first program isn't running */
11958
11959     if(WaitForSecond(TwoMachinesEventIfReady)) return;
11960     DisplayMessage("", "");
11961     InitChessProgram(&second, FALSE);
11962     SendToProgram("force\n", &second);
11963     if(first.lastPing != first.lastPong) { // [HGM] wait till we are sure first engine has set up position
11964       ScheduleDelayedEvent(TwoMachinesEvent, 10);
11965       return;
11966     }
11967     if (startedFromSetupPosition) {
11968         SendBoard(&second, backwardMostMove);
11969     if (appData.debugMode) {
11970         fprintf(debugFP, "Two Machines\n");
11971     }
11972     }
11973     for (i = backwardMostMove; i < forwardMostMove; i++) {
11974         SendMoveToProgram(i, &second);
11975     }
11976
11977     gameMode = TwoMachinesPlay;
11978     pausing = FALSE;
11979     ModeHighlight();
11980     SetGameInfo();
11981     DisplayTwoMachinesTitle();
11982     firstMove = TRUE;
11983     if ((first.twoMachinesColor[0] == 'w') == WhiteOnMove(forwardMostMove)) {
11984         onmove = &first;
11985     } else {
11986         onmove = &second;
11987     }
11988
11989     SendToProgram(first.computerString, &first);
11990     if (first.sendName) {
11991       snprintf(buf, MSG_SIZ, "name %s\n", second.tidy);
11992       SendToProgram(buf, &first);
11993     }
11994     SendToProgram(second.computerString, &second);
11995     if (second.sendName) {
11996       snprintf(buf, MSG_SIZ, "name %s\n", first.tidy);
11997       SendToProgram(buf, &second);
11998     }
11999
12000     ResetClocks();
12001     if (!first.sendTime || !second.sendTime) {
12002         timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
12003         timeRemaining[1][forwardMostMove] = blackTimeRemaining;
12004     }
12005     if (onmove->sendTime) {
12006       if (onmove->useColors) {
12007         SendToProgram(onmove->other->twoMachinesColor, onmove); /*gnu kludge*/
12008       }
12009       SendTimeRemaining(onmove, WhiteOnMove(forwardMostMove));
12010     }
12011     if (onmove->useColors) {
12012       SendToProgram(onmove->twoMachinesColor, onmove);
12013     }
12014     bookHit = SendMoveToBookUser(forwardMostMove-1, onmove, TRUE); // [HGM] book: send go or retrieve book move
12015 //    SendToProgram("go\n", onmove);
12016     onmove->maybeThinking = TRUE;
12017     SetMachineThinkingEnables();
12018
12019     StartClocks();
12020
12021     if(bookHit) { // [HGM] book: simulate book reply
12022         static char bookMove[MSG_SIZ]; // a bit generous?
12023
12024         programStats.nodes = programStats.depth = programStats.time =
12025         programStats.score = programStats.got_only_move = 0;
12026         sprintf(programStats.movelist, "%s (xbook)", bookHit);
12027
12028         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
12029         strcat(bookMove, bookHit);
12030         savedMessage = bookMove; // args for deferred call
12031         savedState = onmove;
12032         ScheduleDelayedEvent(DeferredBookMove, 1);
12033     }
12034 }
12035
12036 void
12037 TrainingEvent()
12038 {
12039     if (gameMode == Training) {
12040       SetTrainingModeOff();
12041       gameMode = PlayFromGameFile;
12042       DisplayMessage("", _("Training mode off"));
12043     } else {
12044       gameMode = Training;
12045       animateTraining = appData.animate;
12046
12047       /* make sure we are not already at the end of the game */
12048       if (currentMove < forwardMostMove) {
12049         SetTrainingModeOn();
12050         DisplayMessage("", _("Training mode on"));
12051       } else {
12052         gameMode = PlayFromGameFile;
12053         DisplayError(_("Already at end of game"), 0);
12054       }
12055     }
12056     ModeHighlight();
12057 }
12058
12059 void
12060 IcsClientEvent()
12061 {
12062     if (!appData.icsActive) return;
12063     switch (gameMode) {
12064       case IcsPlayingWhite:
12065       case IcsPlayingBlack:
12066       case IcsObserving:
12067       case IcsIdle:
12068       case BeginningOfGame:
12069       case IcsExamining:
12070         return;
12071
12072       case EditGame:
12073         break;
12074
12075       case EditPosition:
12076         EditPositionDone(TRUE);
12077         break;
12078
12079       case AnalyzeMode:
12080       case AnalyzeFile:
12081         ExitAnalyzeMode();
12082         break;
12083
12084       default:
12085         EditGameEvent();
12086         break;
12087     }
12088
12089     gameMode = IcsIdle;
12090     ModeHighlight();
12091     return;
12092 }
12093
12094
12095 void
12096 EditGameEvent()
12097 {
12098     int i;
12099
12100     switch (gameMode) {
12101       case Training:
12102         SetTrainingModeOff();
12103         break;
12104       case MachinePlaysWhite:
12105       case MachinePlaysBlack:
12106       case BeginningOfGame:
12107         SendToProgram("force\n", &first);
12108         SetUserThinkingEnables();
12109         break;
12110       case PlayFromGameFile:
12111         (void) StopLoadGameTimer();
12112         if (gameFileFP != NULL) {
12113             gameFileFP = NULL;
12114         }
12115         break;
12116       case EditPosition:
12117         EditPositionDone(TRUE);
12118         break;
12119       case AnalyzeMode:
12120       case AnalyzeFile:
12121         ExitAnalyzeMode();
12122         SendToProgram("force\n", &first);
12123         break;
12124       case TwoMachinesPlay:
12125         GameEnds(EndOfFile, NULL, GE_PLAYER);
12126         ResurrectChessProgram();
12127         SetUserThinkingEnables();
12128         break;
12129       case EndOfGame:
12130         ResurrectChessProgram();
12131         break;
12132       case IcsPlayingBlack:
12133       case IcsPlayingWhite:
12134         DisplayError(_("Warning: You are still playing a game"), 0);
12135         break;
12136       case IcsObserving:
12137         DisplayError(_("Warning: You are still observing a game"), 0);
12138         break;
12139       case IcsExamining:
12140         DisplayError(_("Warning: You are still examining a game"), 0);
12141         break;
12142       case IcsIdle:
12143         break;
12144       case EditGame:
12145       default:
12146         return;
12147     }
12148
12149     pausing = FALSE;
12150     StopClocks();
12151     first.offeredDraw = second.offeredDraw = 0;
12152
12153     if (gameMode == PlayFromGameFile) {
12154         whiteTimeRemaining = timeRemaining[0][currentMove];
12155         blackTimeRemaining = timeRemaining[1][currentMove];
12156         DisplayTitle("");
12157     }
12158
12159     if (gameMode == MachinePlaysWhite ||
12160         gameMode == MachinePlaysBlack ||
12161         gameMode == TwoMachinesPlay ||
12162         gameMode == EndOfGame) {
12163         i = forwardMostMove;
12164         while (i > currentMove) {
12165             SendToProgram("undo\n", &first);
12166             i--;
12167         }
12168         whiteTimeRemaining = timeRemaining[0][currentMove];
12169         blackTimeRemaining = timeRemaining[1][currentMove];
12170         DisplayBothClocks();
12171         if (whiteFlag || blackFlag) {
12172             whiteFlag = blackFlag = 0;
12173         }
12174         DisplayTitle("");
12175     }
12176
12177     gameMode = EditGame;
12178     ModeHighlight();
12179     SetGameInfo();
12180 }
12181
12182
12183 void
12184 EditPositionEvent()
12185 {
12186     if (gameMode == EditPosition) {
12187         EditGameEvent();
12188         return;
12189     }
12190
12191     EditGameEvent();
12192     if (gameMode != EditGame) return;
12193
12194     gameMode = EditPosition;
12195     ModeHighlight();
12196     SetGameInfo();
12197     if (currentMove > 0)
12198       CopyBoard(boards[0], boards[currentMove]);
12199
12200     blackPlaysFirst = !WhiteOnMove(currentMove);
12201     ResetClocks();
12202     currentMove = forwardMostMove = backwardMostMove = 0;
12203     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
12204     DisplayMove(-1);
12205 }
12206
12207 void
12208 ExitAnalyzeMode()
12209 {
12210     /* [DM] icsEngineAnalyze - possible call from other functions */
12211     if (appData.icsEngineAnalyze) {
12212         appData.icsEngineAnalyze = FALSE;
12213
12214         DisplayMessage("",_("Close ICS engine analyze..."));
12215     }
12216     if (first.analysisSupport && first.analyzing) {
12217       SendToProgram("exit\n", &first);
12218       first.analyzing = FALSE;
12219     }
12220     thinkOutput[0] = NULLCHAR;
12221 }
12222
12223 void
12224 EditPositionDone(Boolean fakeRights)
12225 {
12226     int king = gameInfo.variant == VariantKnightmate ? WhiteUnicorn : WhiteKing;
12227
12228     startedFromSetupPosition = TRUE;
12229     InitChessProgram(&first, FALSE);
12230     if(fakeRights) { // [HGM] suppress this if we just pasted a FEN.
12231       boards[0][EP_STATUS] = EP_NONE;
12232       boards[0][CASTLING][2] = boards[0][CASTLING][5] = BOARD_WIDTH>>1;
12233     if(boards[0][0][BOARD_WIDTH>>1] == king) {
12234         boards[0][CASTLING][1] = boards[0][0][BOARD_LEFT] == WhiteRook ? 0 : NoRights;
12235         boards[0][CASTLING][0] = boards[0][0][BOARD_RGHT-1] == WhiteRook ? BOARD_RGHT-1 : NoRights;
12236       } else boards[0][CASTLING][2] = NoRights;
12237     if(boards[0][BOARD_HEIGHT-1][BOARD_WIDTH>>1] == WHITE_TO_BLACK king) {
12238         boards[0][CASTLING][4] = boards[0][BOARD_HEIGHT-1][BOARD_LEFT] == BlackRook ? 0 : NoRights;
12239         boards[0][CASTLING][3] = boards[0][BOARD_HEIGHT-1][BOARD_RGHT-1] == BlackRook ? BOARD_RGHT-1 : NoRights;
12240       } else boards[0][CASTLING][5] = NoRights;
12241     }
12242     SendToProgram("force\n", &first);
12243     if (blackPlaysFirst) {
12244         safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
12245         safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
12246         currentMove = forwardMostMove = backwardMostMove = 1;
12247         CopyBoard(boards[1], boards[0]);
12248     } else {
12249         currentMove = forwardMostMove = backwardMostMove = 0;
12250     }
12251     SendBoard(&first, forwardMostMove);
12252     if (appData.debugMode) {
12253         fprintf(debugFP, "EditPosDone\n");
12254     }
12255     DisplayTitle("");
12256     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
12257     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
12258     gameMode = EditGame;
12259     ModeHighlight();
12260     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
12261     ClearHighlights(); /* [AS] */
12262 }
12263
12264 /* Pause for `ms' milliseconds */
12265 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
12266 void
12267 TimeDelay(ms)
12268      long ms;
12269 {
12270     TimeMark m1, m2;
12271
12272     GetTimeMark(&m1);
12273     do {
12274         GetTimeMark(&m2);
12275     } while (SubtractTimeMarks(&m2, &m1) < ms);
12276 }
12277
12278 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
12279 void
12280 SendMultiLineToICS(buf)
12281      char *buf;
12282 {
12283     char temp[MSG_SIZ+1], *p;
12284     int len;
12285
12286     len = strlen(buf);
12287     if (len > MSG_SIZ)
12288       len = MSG_SIZ;
12289
12290     strncpy(temp, buf, len);
12291     temp[len] = 0;
12292
12293     p = temp;
12294     while (*p) {
12295         if (*p == '\n' || *p == '\r')
12296           *p = ' ';
12297         ++p;
12298     }
12299
12300     strcat(temp, "\n");
12301     SendToICS(temp);
12302     SendToPlayer(temp, strlen(temp));
12303 }
12304
12305 void
12306 SetWhiteToPlayEvent()
12307 {
12308     if (gameMode == EditPosition) {
12309         blackPlaysFirst = FALSE;
12310         DisplayBothClocks();    /* works because currentMove is 0 */
12311     } else if (gameMode == IcsExamining) {
12312         SendToICS(ics_prefix);
12313         SendToICS("tomove white\n");
12314     }
12315 }
12316
12317 void
12318 SetBlackToPlayEvent()
12319 {
12320     if (gameMode == EditPosition) {
12321         blackPlaysFirst = TRUE;
12322         currentMove = 1;        /* kludge */
12323         DisplayBothClocks();
12324         currentMove = 0;
12325     } else if (gameMode == IcsExamining) {
12326         SendToICS(ics_prefix);
12327         SendToICS("tomove black\n");
12328     }
12329 }
12330
12331 void
12332 EditPositionMenuEvent(selection, x, y)
12333      ChessSquare selection;
12334      int x, y;
12335 {
12336     char buf[MSG_SIZ];
12337     ChessSquare piece = boards[0][y][x];
12338
12339     if (gameMode != EditPosition && gameMode != IcsExamining) return;
12340
12341     switch (selection) {
12342       case ClearBoard:
12343         if (gameMode == IcsExamining && ics_type == ICS_FICS) {
12344             SendToICS(ics_prefix);
12345             SendToICS("bsetup clear\n");
12346         } else if (gameMode == IcsExamining && ics_type == ICS_ICC) {
12347             SendToICS(ics_prefix);
12348             SendToICS("clearboard\n");
12349         } else {
12350             for (x = 0; x < BOARD_WIDTH; x++) { ChessSquare p = EmptySquare;
12351                 if(x == BOARD_LEFT-1 || x == BOARD_RGHT) p = (ChessSquare) 0; /* [HGM] holdings */
12352                 for (y = 0; y < BOARD_HEIGHT; y++) {
12353                     if (gameMode == IcsExamining) {
12354                         if (boards[currentMove][y][x] != EmptySquare) {
12355                           snprintf(buf, MSG_SIZ, "%sx@%c%c\n", ics_prefix,
12356                                     AAA + x, ONE + y);
12357                             SendToICS(buf);
12358                         }
12359                     } else {
12360                         boards[0][y][x] = p;
12361                     }
12362                 }
12363             }
12364         }
12365         if (gameMode == EditPosition) {
12366             DrawPosition(FALSE, boards[0]);
12367         }
12368         break;
12369
12370       case WhitePlay:
12371         SetWhiteToPlayEvent();
12372         break;
12373
12374       case BlackPlay:
12375         SetBlackToPlayEvent();
12376         break;
12377
12378       case EmptySquare:
12379         if (gameMode == IcsExamining) {
12380             if (x < BOARD_LEFT || x >= BOARD_RGHT) break; // [HGM] holdings
12381             snprintf(buf, MSG_SIZ, "%sx@%c%c\n", ics_prefix, AAA + x, ONE + y);
12382             SendToICS(buf);
12383         } else {
12384             if(x < BOARD_LEFT || x >= BOARD_RGHT) {
12385                 if(x == BOARD_LEFT-2) {
12386                     if(y < BOARD_HEIGHT-1-gameInfo.holdingsSize) break;
12387                     boards[0][y][1] = 0;
12388                 } else
12389                 if(x == BOARD_RGHT+1) {
12390                     if(y >= gameInfo.holdingsSize) break;
12391                     boards[0][y][BOARD_WIDTH-2] = 0;
12392                 } else break;
12393             }
12394             boards[0][y][x] = EmptySquare;
12395             DrawPosition(FALSE, boards[0]);
12396         }
12397         break;
12398
12399       case PromotePiece:
12400         if(piece >= (int)WhitePawn && piece < (int)WhiteMan ||
12401            piece >= (int)BlackPawn && piece < (int)BlackMan   ) {
12402             selection = (ChessSquare) (PROMOTED piece);
12403         } else if(piece == EmptySquare) selection = WhiteSilver;
12404         else selection = (ChessSquare)((int)piece - 1);
12405         goto defaultlabel;
12406
12407       case DemotePiece:
12408         if(piece > (int)WhiteMan && piece <= (int)WhiteKing ||
12409            piece > (int)BlackMan && piece <= (int)BlackKing   ) {
12410             selection = (ChessSquare) (DEMOTED piece);
12411         } else if(piece == EmptySquare) selection = BlackSilver;
12412         else selection = (ChessSquare)((int)piece + 1);
12413         goto defaultlabel;
12414
12415       case WhiteQueen:
12416       case BlackQueen:
12417         if(gameInfo.variant == VariantShatranj ||
12418            gameInfo.variant == VariantXiangqi  ||
12419            gameInfo.variant == VariantCourier  ||
12420            gameInfo.variant == VariantMakruk     )
12421             selection = (ChessSquare)((int)selection - (int)WhiteQueen + (int)WhiteFerz);
12422         goto defaultlabel;
12423
12424       case WhiteKing:
12425       case BlackKing:
12426         if(gameInfo.variant == VariantXiangqi)
12427             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteWazir);
12428         if(gameInfo.variant == VariantKnightmate)
12429             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteUnicorn);
12430       default:
12431         defaultlabel:
12432         if (gameMode == IcsExamining) {
12433             if (x < BOARD_LEFT || x >= BOARD_RGHT) break; // [HGM] holdings
12434             snprintf(buf, MSG_SIZ, "%s%c@%c%c\n", ics_prefix,
12435                      PieceToChar(selection), AAA + x, ONE + y);
12436             SendToICS(buf);
12437         } else {
12438             if(x < BOARD_LEFT || x >= BOARD_RGHT) {
12439                 int n;
12440                 if(x == BOARD_LEFT-2 && selection >= BlackPawn) {
12441                     n = PieceToNumber(selection - BlackPawn);
12442                     if(n >= gameInfo.holdingsSize) { n = 0; selection = BlackPawn; }
12443                     boards[0][BOARD_HEIGHT-1-n][0] = selection;
12444                     boards[0][BOARD_HEIGHT-1-n][1]++;
12445                 } else
12446                 if(x == BOARD_RGHT+1 && selection < BlackPawn) {
12447                     n = PieceToNumber(selection);
12448                     if(n >= gameInfo.holdingsSize) { n = 0; selection = WhitePawn; }
12449                     boards[0][n][BOARD_WIDTH-1] = selection;
12450                     boards[0][n][BOARD_WIDTH-2]++;
12451                 }
12452             } else
12453             boards[0][y][x] = selection;
12454             DrawPosition(TRUE, boards[0]);
12455         }
12456         break;
12457     }
12458 }
12459
12460
12461 void
12462 DropMenuEvent(selection, x, y)
12463      ChessSquare selection;
12464      int x, y;
12465 {
12466     ChessMove moveType;
12467
12468     switch (gameMode) {
12469       case IcsPlayingWhite:
12470       case MachinePlaysBlack:
12471         if (!WhiteOnMove(currentMove)) {
12472             DisplayMoveError(_("It is Black's turn"));
12473             return;
12474         }
12475         moveType = WhiteDrop;
12476         break;
12477       case IcsPlayingBlack:
12478       case MachinePlaysWhite:
12479         if (WhiteOnMove(currentMove)) {
12480             DisplayMoveError(_("It is White's turn"));
12481             return;
12482         }
12483         moveType = BlackDrop;
12484         break;
12485       case EditGame:
12486         moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
12487         break;
12488       default:
12489         return;
12490     }
12491
12492     if (moveType == BlackDrop && selection < BlackPawn) {
12493       selection = (ChessSquare) ((int) selection
12494                                  + (int) BlackPawn - (int) WhitePawn);
12495     }
12496     if (boards[currentMove][y][x] != EmptySquare) {
12497         DisplayMoveError(_("That square is occupied"));
12498         return;
12499     }
12500
12501     FinishMove(moveType, (int) selection, DROP_RANK, x, y, NULLCHAR);
12502 }
12503
12504 void
12505 AcceptEvent()
12506 {
12507     /* Accept a pending offer of any kind from opponent */
12508
12509     if (appData.icsActive) {
12510         SendToICS(ics_prefix);
12511         SendToICS("accept\n");
12512     } else if (cmailMsgLoaded) {
12513         if (currentMove == cmailOldMove &&
12514             commentList[cmailOldMove] != NULL &&
12515             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
12516                    "Black offers a draw" : "White offers a draw")) {
12517             TruncateGame();
12518             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
12519             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
12520         } else {
12521             DisplayError(_("There is no pending offer on this move"), 0);
12522             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
12523         }
12524     } else {
12525         /* Not used for offers from chess program */
12526     }
12527 }
12528
12529 void
12530 DeclineEvent()
12531 {
12532     /* Decline a pending offer of any kind from opponent */
12533
12534     if (appData.icsActive) {
12535         SendToICS(ics_prefix);
12536         SendToICS("decline\n");
12537     } else if (cmailMsgLoaded) {
12538         if (currentMove == cmailOldMove &&
12539             commentList[cmailOldMove] != NULL &&
12540             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
12541                    "Black offers a draw" : "White offers a draw")) {
12542 #ifdef NOTDEF
12543             AppendComment(cmailOldMove, "Draw declined", TRUE);
12544             DisplayComment(cmailOldMove - 1, "Draw declined");
12545 #endif /*NOTDEF*/
12546         } else {
12547             DisplayError(_("There is no pending offer on this move"), 0);
12548         }
12549     } else {
12550         /* Not used for offers from chess program */
12551     }
12552 }
12553
12554 void
12555 RematchEvent()
12556 {
12557     /* Issue ICS rematch command */
12558     if (appData.icsActive) {
12559         SendToICS(ics_prefix);
12560         SendToICS("rematch\n");
12561     }
12562 }
12563
12564 void
12565 CallFlagEvent()
12566 {
12567     /* Call your opponent's flag (claim a win on time) */
12568     if (appData.icsActive) {
12569         SendToICS(ics_prefix);
12570         SendToICS("flag\n");
12571     } else {
12572         switch (gameMode) {
12573           default:
12574             return;
12575           case MachinePlaysWhite:
12576             if (whiteFlag) {
12577                 if (blackFlag)
12578                   GameEnds(GameIsDrawn, "Both players ran out of time",
12579                            GE_PLAYER);
12580                 else
12581                   GameEnds(BlackWins, "Black wins on time", GE_PLAYER);
12582             } else {
12583                 DisplayError(_("Your opponent is not out of time"), 0);
12584             }
12585             break;
12586           case MachinePlaysBlack:
12587             if (blackFlag) {
12588                 if (whiteFlag)
12589                   GameEnds(GameIsDrawn, "Both players ran out of time",
12590                            GE_PLAYER);
12591                 else
12592                   GameEnds(WhiteWins, "White wins on time", GE_PLAYER);
12593             } else {
12594                 DisplayError(_("Your opponent is not out of time"), 0);
12595             }
12596             break;
12597         }
12598     }
12599 }
12600
12601 void
12602 DrawEvent()
12603 {
12604     /* Offer draw or accept pending draw offer from opponent */
12605
12606     if (appData.icsActive) {
12607         /* Note: tournament rules require draw offers to be
12608            made after you make your move but before you punch
12609            your clock.  Currently ICS doesn't let you do that;
12610            instead, you immediately punch your clock after making
12611            a move, but you can offer a draw at any time. */
12612
12613         SendToICS(ics_prefix);
12614         SendToICS("draw\n");
12615         userOfferedDraw = TRUE; // [HGM] drawclaim: also set flag in ICS play
12616     } else if (cmailMsgLoaded) {
12617         if (currentMove == cmailOldMove &&
12618             commentList[cmailOldMove] != NULL &&
12619             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
12620                    "Black offers a draw" : "White offers a draw")) {
12621             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
12622             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
12623         } else if (currentMove == cmailOldMove + 1) {
12624             char *offer = WhiteOnMove(cmailOldMove) ?
12625               "White offers a draw" : "Black offers a draw";
12626             AppendComment(currentMove, offer, TRUE);
12627             DisplayComment(currentMove - 1, offer);
12628             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_DRAW;
12629         } else {
12630             DisplayError(_("You must make your move before offering a draw"), 0);
12631             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
12632         }
12633     } else if (first.offeredDraw) {
12634         GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
12635     } else {
12636         if (first.sendDrawOffers) {
12637             SendToProgram("draw\n", &first);
12638             userOfferedDraw = TRUE;
12639         }
12640     }
12641 }
12642
12643 void
12644 AdjournEvent()
12645 {
12646     /* Offer Adjourn or accept pending Adjourn offer from opponent */
12647
12648     if (appData.icsActive) {
12649         SendToICS(ics_prefix);
12650         SendToICS("adjourn\n");
12651     } else {
12652         /* Currently GNU Chess doesn't offer or accept Adjourns */
12653     }
12654 }
12655
12656
12657 void
12658 AbortEvent()
12659 {
12660     /* Offer Abort or accept pending Abort offer from opponent */
12661
12662     if (appData.icsActive) {
12663         SendToICS(ics_prefix);
12664         SendToICS("abort\n");
12665     } else {
12666         GameEnds(GameUnfinished, "Game aborted", GE_PLAYER);
12667     }
12668 }
12669
12670 void
12671 ResignEvent()
12672 {
12673     /* Resign.  You can do this even if it's not your turn. */
12674
12675     if (appData.icsActive) {
12676         SendToICS(ics_prefix);
12677         SendToICS("resign\n");
12678     } else {
12679         switch (gameMode) {
12680           case MachinePlaysWhite:
12681             GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
12682             break;
12683           case MachinePlaysBlack:
12684             GameEnds(BlackWins, "White resigns", GE_PLAYER);
12685             break;
12686           case EditGame:
12687             if (cmailMsgLoaded) {
12688                 TruncateGame();
12689                 if (WhiteOnMove(cmailOldMove)) {
12690                     GameEnds(BlackWins, "White resigns", GE_PLAYER);
12691                 } else {
12692                     GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
12693                 }
12694                 cmailMoveType[lastLoadGameNumber - 1] = CMAIL_RESIGN;
12695             }
12696             break;
12697           default:
12698             break;
12699         }
12700     }
12701 }
12702
12703
12704 void
12705 StopObservingEvent()
12706 {
12707     /* Stop observing current games */
12708     SendToICS(ics_prefix);
12709     SendToICS("unobserve\n");
12710 }
12711
12712 void
12713 StopExaminingEvent()
12714 {
12715     /* Stop observing current game */
12716     SendToICS(ics_prefix);
12717     SendToICS("unexamine\n");
12718 }
12719
12720 void
12721 ForwardInner(target)
12722      int target;
12723 {
12724     int limit;
12725
12726     if (appData.debugMode)
12727         fprintf(debugFP, "ForwardInner(%d), current %d, forward %d\n",
12728                 target, currentMove, forwardMostMove);
12729
12730     if (gameMode == EditPosition)
12731       return;
12732
12733     if (gameMode == PlayFromGameFile && !pausing)
12734       PauseEvent();
12735
12736     if (gameMode == IcsExamining && pausing)
12737       limit = pauseExamForwardMostMove;
12738     else
12739       limit = forwardMostMove;
12740
12741     if (target > limit) target = limit;
12742
12743     if (target > 0 && moveList[target - 1][0]) {
12744         int fromX, fromY, toX, toY;
12745         toX = moveList[target - 1][2] - AAA;
12746         toY = moveList[target - 1][3] - ONE;
12747         if (moveList[target - 1][1] == '@') {
12748             if (appData.highlightLastMove) {
12749                 SetHighlights(-1, -1, toX, toY);
12750             }
12751         } else {
12752             fromX = moveList[target - 1][0] - AAA;
12753             fromY = moveList[target - 1][1] - ONE;
12754             if (target == currentMove + 1) {
12755                 AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
12756             }
12757             if (appData.highlightLastMove) {
12758                 SetHighlights(fromX, fromY, toX, toY);
12759             }
12760         }
12761     }
12762     if (gameMode == EditGame || gameMode == AnalyzeMode ||
12763         gameMode == Training || gameMode == PlayFromGameFile ||
12764         gameMode == AnalyzeFile) {
12765         while (currentMove < target) {
12766             SendMoveToProgram(currentMove++, &first);
12767         }
12768     } else {
12769         currentMove = target;
12770     }
12771
12772     if (gameMode == EditGame || gameMode == EndOfGame) {
12773         whiteTimeRemaining = timeRemaining[0][currentMove];
12774         blackTimeRemaining = timeRemaining[1][currentMove];
12775     }
12776     DisplayBothClocks();
12777     DisplayMove(currentMove - 1);
12778     DrawPosition(FALSE, boards[currentMove]);
12779     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
12780     if ( !matchMode && gameMode != Training) { // [HGM] PV info: routine tests if empty
12781         DisplayComment(currentMove - 1, commentList[currentMove]);
12782     }
12783 }
12784
12785
12786 void
12787 ForwardEvent()
12788 {
12789     if (gameMode == IcsExamining && !pausing) {
12790         SendToICS(ics_prefix);
12791         SendToICS("forward\n");
12792     } else {
12793         ForwardInner(currentMove + 1);
12794     }
12795 }
12796
12797 void
12798 ToEndEvent()
12799 {
12800     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12801         /* to optimze, we temporarily turn off analysis mode while we feed
12802          * the remaining moves to the engine. Otherwise we get analysis output
12803          * after each move.
12804          */
12805         if (first.analysisSupport) {
12806           SendToProgram("exit\nforce\n", &first);
12807           first.analyzing = FALSE;
12808         }
12809     }
12810
12811     if (gameMode == IcsExamining && !pausing) {
12812         SendToICS(ics_prefix);
12813         SendToICS("forward 999999\n");
12814     } else {
12815         ForwardInner(forwardMostMove);
12816     }
12817
12818     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12819         /* we have fed all the moves, so reactivate analysis mode */
12820         SendToProgram("analyze\n", &first);
12821         first.analyzing = TRUE;
12822         /*first.maybeThinking = TRUE;*/
12823         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
12824     }
12825 }
12826
12827 void
12828 BackwardInner(target)
12829      int target;
12830 {
12831     int full_redraw = TRUE; /* [AS] Was FALSE, had to change it! */
12832
12833     if (appData.debugMode)
12834         fprintf(debugFP, "BackwardInner(%d), current %d, forward %d\n",
12835                 target, currentMove, forwardMostMove);
12836
12837     if (gameMode == EditPosition) return;
12838     if (currentMove <= backwardMostMove) {
12839         ClearHighlights();
12840         DrawPosition(full_redraw, boards[currentMove]);
12841         return;
12842     }
12843     if (gameMode == PlayFromGameFile && !pausing)
12844       PauseEvent();
12845
12846     if (moveList[target][0]) {
12847         int fromX, fromY, toX, toY;
12848         toX = moveList[target][2] - AAA;
12849         toY = moveList[target][3] - ONE;
12850         if (moveList[target][1] == '@') {
12851             if (appData.highlightLastMove) {
12852                 SetHighlights(-1, -1, toX, toY);
12853             }
12854         } else {
12855             fromX = moveList[target][0] - AAA;
12856             fromY = moveList[target][1] - ONE;
12857             if (target == currentMove - 1) {
12858                 AnimateMove(boards[currentMove], toX, toY, fromX, fromY);
12859             }
12860             if (appData.highlightLastMove) {
12861                 SetHighlights(fromX, fromY, toX, toY);
12862             }
12863         }
12864     }
12865     if (gameMode == EditGame || gameMode==AnalyzeMode ||
12866         gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
12867         while (currentMove > target) {
12868             SendToProgram("undo\n", &first);
12869             currentMove--;
12870         }
12871     } else {
12872         currentMove = target;
12873     }
12874
12875     if (gameMode == EditGame || gameMode == EndOfGame) {
12876         whiteTimeRemaining = timeRemaining[0][currentMove];
12877         blackTimeRemaining = timeRemaining[1][currentMove];
12878     }
12879     DisplayBothClocks();
12880     DisplayMove(currentMove - 1);
12881     DrawPosition(full_redraw, boards[currentMove]);
12882     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
12883     // [HGM] PV info: routine tests if comment empty
12884     DisplayComment(currentMove - 1, commentList[currentMove]);
12885 }
12886
12887 void
12888 BackwardEvent()
12889 {
12890     if (gameMode == IcsExamining && !pausing) {
12891         SendToICS(ics_prefix);
12892         SendToICS("backward\n");
12893     } else {
12894         BackwardInner(currentMove - 1);
12895     }
12896 }
12897
12898 void
12899 ToStartEvent()
12900 {
12901     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12902         /* to optimize, we temporarily turn off analysis mode while we undo
12903          * all the moves. Otherwise we get analysis output after each undo.
12904          */
12905         if (first.analysisSupport) {
12906           SendToProgram("exit\nforce\n", &first);
12907           first.analyzing = FALSE;
12908         }
12909     }
12910
12911     if (gameMode == IcsExamining && !pausing) {
12912         SendToICS(ics_prefix);
12913         SendToICS("backward 999999\n");
12914     } else {
12915         BackwardInner(backwardMostMove);
12916     }
12917
12918     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12919         /* we have fed all the moves, so reactivate analysis mode */
12920         SendToProgram("analyze\n", &first);
12921         first.analyzing = TRUE;
12922         /*first.maybeThinking = TRUE;*/
12923         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
12924     }
12925 }
12926
12927 void
12928 ToNrEvent(int to)
12929 {
12930   if (gameMode == PlayFromGameFile && !pausing) PauseEvent();
12931   if (to >= forwardMostMove) to = forwardMostMove;
12932   if (to <= backwardMostMove) to = backwardMostMove;
12933   if (to < currentMove) {
12934     BackwardInner(to);
12935   } else {
12936     ForwardInner(to);
12937   }
12938 }
12939
12940 void
12941 RevertEvent(Boolean annotate)
12942 {
12943     if(PopTail(annotate)) { // [HGM] vari: restore old game tail
12944         return;
12945     }
12946     if (gameMode != IcsExamining) {
12947         DisplayError(_("You are not examining a game"), 0);
12948         return;
12949     }
12950     if (pausing) {
12951         DisplayError(_("You can't revert while pausing"), 0);
12952         return;
12953     }
12954     SendToICS(ics_prefix);
12955     SendToICS("revert\n");
12956 }
12957
12958 void
12959 RetractMoveEvent()
12960 {
12961     switch (gameMode) {
12962       case MachinePlaysWhite:
12963       case MachinePlaysBlack:
12964         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
12965             DisplayError(_("Wait until your turn,\nor select Move Now"), 0);
12966             return;
12967         }
12968         if (forwardMostMove < 2) return;
12969         currentMove = forwardMostMove = forwardMostMove - 2;
12970         whiteTimeRemaining = timeRemaining[0][currentMove];
12971         blackTimeRemaining = timeRemaining[1][currentMove];
12972         DisplayBothClocks();
12973         DisplayMove(currentMove - 1);
12974         ClearHighlights();/*!! could figure this out*/
12975         DrawPosition(TRUE, boards[currentMove]); /* [AS] Changed to full redraw! */
12976         SendToProgram("remove\n", &first);
12977         /*first.maybeThinking = TRUE;*/ /* GNU Chess does not ponder here */
12978         break;
12979
12980       case BeginningOfGame:
12981       default:
12982         break;
12983
12984       case IcsPlayingWhite:
12985       case IcsPlayingBlack:
12986         if (WhiteOnMove(forwardMostMove) == (gameMode == IcsPlayingWhite)) {
12987             SendToICS(ics_prefix);
12988             SendToICS("takeback 2\n");
12989         } else {
12990             SendToICS(ics_prefix);
12991             SendToICS("takeback 1\n");
12992         }
12993         break;
12994     }
12995 }
12996
12997 void
12998 MoveNowEvent()
12999 {
13000     ChessProgramState *cps;
13001
13002     switch (gameMode) {
13003       case MachinePlaysWhite:
13004         if (!WhiteOnMove(forwardMostMove)) {
13005             DisplayError(_("It is your turn"), 0);
13006             return;
13007         }
13008         cps = &first;
13009         break;
13010       case MachinePlaysBlack:
13011         if (WhiteOnMove(forwardMostMove)) {
13012             DisplayError(_("It is your turn"), 0);
13013             return;
13014         }
13015         cps = &first;
13016         break;
13017       case TwoMachinesPlay:
13018         if (WhiteOnMove(forwardMostMove) ==
13019             (first.twoMachinesColor[0] == 'w')) {
13020             cps = &first;
13021         } else {
13022             cps = &second;
13023         }
13024         break;
13025       case BeginningOfGame:
13026       default:
13027         return;
13028     }
13029     SendToProgram("?\n", cps);
13030 }
13031
13032 void
13033 TruncateGameEvent()
13034 {
13035     EditGameEvent();
13036     if (gameMode != EditGame) return;
13037     TruncateGame();
13038 }
13039
13040 void
13041 TruncateGame()
13042 {
13043     CleanupTail(); // [HGM] vari: only keep current variation if we explicitly truncate
13044     if (forwardMostMove > currentMove) {
13045         if (gameInfo.resultDetails != NULL) {
13046             free(gameInfo.resultDetails);
13047             gameInfo.resultDetails = NULL;
13048             gameInfo.result = GameUnfinished;
13049         }
13050         forwardMostMove = currentMove;
13051         HistorySet(parseList, backwardMostMove, forwardMostMove,
13052                    currentMove-1);
13053     }
13054 }
13055
13056 void
13057 HintEvent()
13058 {
13059     if (appData.noChessProgram) return;
13060     switch (gameMode) {
13061       case MachinePlaysWhite:
13062         if (WhiteOnMove(forwardMostMove)) {
13063             DisplayError(_("Wait until your turn"), 0);
13064             return;
13065         }
13066         break;
13067       case BeginningOfGame:
13068       case MachinePlaysBlack:
13069         if (!WhiteOnMove(forwardMostMove)) {
13070             DisplayError(_("Wait until your turn"), 0);
13071             return;
13072         }
13073         break;
13074       default:
13075         DisplayError(_("No hint available"), 0);
13076         return;
13077     }
13078     SendToProgram("hint\n", &first);
13079     hintRequested = TRUE;
13080 }
13081
13082 void
13083 BookEvent()
13084 {
13085     if (appData.noChessProgram) return;
13086     switch (gameMode) {
13087       case MachinePlaysWhite:
13088         if (WhiteOnMove(forwardMostMove)) {
13089             DisplayError(_("Wait until your turn"), 0);
13090             return;
13091         }
13092         break;
13093       case BeginningOfGame:
13094       case MachinePlaysBlack:
13095         if (!WhiteOnMove(forwardMostMove)) {
13096             DisplayError(_("Wait until your turn"), 0);
13097             return;
13098         }
13099         break;
13100       case EditPosition:
13101         EditPositionDone(TRUE);
13102         break;
13103       case TwoMachinesPlay:
13104         return;
13105       default:
13106         break;
13107     }
13108     SendToProgram("bk\n", &first);
13109     bookOutput[0] = NULLCHAR;
13110     bookRequested = TRUE;
13111 }
13112
13113 void
13114 AboutGameEvent()
13115 {
13116     char *tags = PGNTags(&gameInfo);
13117     TagsPopUp(tags, CmailMsg());
13118     free(tags);
13119 }
13120
13121 /* end button procedures */
13122
13123 void
13124 PrintPosition(fp, move)
13125      FILE *fp;
13126      int move;
13127 {
13128     int i, j;
13129
13130     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
13131         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
13132             char c = PieceToChar(boards[move][i][j]);
13133             fputc(c == 'x' ? '.' : c, fp);
13134             fputc(j == BOARD_RGHT - 1 ? '\n' : ' ', fp);
13135         }
13136     }
13137     if ((gameMode == EditPosition) ? !blackPlaysFirst : (move % 2 == 0))
13138       fprintf(fp, "white to play\n");
13139     else
13140       fprintf(fp, "black to play\n");
13141 }
13142
13143 void
13144 PrintOpponents(fp)
13145      FILE *fp;
13146 {
13147     if (gameInfo.white != NULL) {
13148         fprintf(fp, "\t%s vs. %s\n", gameInfo.white, gameInfo.black);
13149     } else {
13150         fprintf(fp, "\n");
13151     }
13152 }
13153
13154 /* Find last component of program's own name, using some heuristics */
13155 void
13156 TidyProgramName(prog, host, buf)
13157      char *prog, *host, buf[MSG_SIZ];
13158 {
13159     char *p, *q;
13160     int local = (strcmp(host, "localhost") == 0);
13161     while (!local && (p = strchr(prog, ';')) != NULL) {
13162         p++;
13163         while (*p == ' ') p++;
13164         prog = p;
13165     }
13166     if (*prog == '"' || *prog == '\'') {
13167         q = strchr(prog + 1, *prog);
13168     } else {
13169         q = strchr(prog, ' ');
13170     }
13171     if (q == NULL) q = prog + strlen(prog);
13172     p = q;
13173     while (p >= prog && *p != '/' && *p != '\\') p--;
13174     p++;
13175     if(p == prog && *p == '"') p++;
13176     if (q - p >= 4 && StrCaseCmp(q - 4, ".exe") == 0) q -= 4;
13177     memcpy(buf, p, q - p);
13178     buf[q - p] = NULLCHAR;
13179     if (!local) {
13180         strcat(buf, "@");
13181         strcat(buf, host);
13182     }
13183 }
13184
13185 char *
13186 TimeControlTagValue()
13187 {
13188     char buf[MSG_SIZ];
13189     if (!appData.clockMode) {
13190       safeStrCpy(buf, "-", sizeof(buf)/sizeof(buf[0]));
13191     } else if (movesPerSession > 0) {
13192       snprintf(buf, MSG_SIZ, "%d/%ld", movesPerSession, timeControl/1000);
13193     } else if (timeIncrement == 0) {
13194       snprintf(buf, MSG_SIZ, "%ld", timeControl/1000);
13195     } else {
13196       snprintf(buf, MSG_SIZ, "%ld+%ld", timeControl/1000, timeIncrement/1000);
13197     }
13198     return StrSave(buf);
13199 }
13200
13201 void
13202 SetGameInfo()
13203 {
13204     /* This routine is used only for certain modes */
13205     VariantClass v = gameInfo.variant;
13206     ChessMove r = GameUnfinished;
13207     char *p = NULL;
13208
13209     if(gameMode == EditGame) { // [HGM] vari: do not erase result on EditGame
13210         r = gameInfo.result;
13211         p = gameInfo.resultDetails;
13212         gameInfo.resultDetails = NULL;
13213     }
13214     ClearGameInfo(&gameInfo);
13215     gameInfo.variant = v;
13216
13217     switch (gameMode) {
13218       case MachinePlaysWhite:
13219         gameInfo.event = StrSave( appData.pgnEventHeader );
13220         gameInfo.site = StrSave(HostName());
13221         gameInfo.date = PGNDate();
13222         gameInfo.round = StrSave("-");
13223         gameInfo.white = StrSave(first.tidy);
13224         gameInfo.black = StrSave(UserName());
13225         gameInfo.timeControl = TimeControlTagValue();
13226         break;
13227
13228       case MachinePlaysBlack:
13229         gameInfo.event = StrSave( appData.pgnEventHeader );
13230         gameInfo.site = StrSave(HostName());
13231         gameInfo.date = PGNDate();
13232         gameInfo.round = StrSave("-");
13233         gameInfo.white = StrSave(UserName());
13234         gameInfo.black = StrSave(first.tidy);
13235         gameInfo.timeControl = TimeControlTagValue();
13236         break;
13237
13238       case TwoMachinesPlay:
13239         gameInfo.event = StrSave( appData.pgnEventHeader );
13240         gameInfo.site = StrSave(HostName());
13241         gameInfo.date = PGNDate();
13242         if (matchGame > 0) {
13243             char buf[MSG_SIZ];
13244             snprintf(buf, MSG_SIZ, "%d", matchGame);
13245             gameInfo.round = StrSave(buf);
13246         } else {
13247             gameInfo.round = StrSave("-");
13248         }
13249         if (first.twoMachinesColor[0] == 'w') {
13250             gameInfo.white = StrSave(first.tidy);
13251             gameInfo.black = StrSave(second.tidy);
13252         } else {
13253             gameInfo.white = StrSave(second.tidy);
13254             gameInfo.black = StrSave(first.tidy);
13255         }
13256         gameInfo.timeControl = TimeControlTagValue();
13257         break;
13258
13259       case EditGame:
13260         gameInfo.event = StrSave("Edited game");
13261         gameInfo.site = StrSave(HostName());
13262         gameInfo.date = PGNDate();
13263         gameInfo.round = StrSave("-");
13264         gameInfo.white = StrSave("-");
13265         gameInfo.black = StrSave("-");
13266         gameInfo.result = r;
13267         gameInfo.resultDetails = p;
13268         break;
13269
13270       case EditPosition:
13271         gameInfo.event = StrSave("Edited position");
13272         gameInfo.site = StrSave(HostName());
13273         gameInfo.date = PGNDate();
13274         gameInfo.round = StrSave("-");
13275         gameInfo.white = StrSave("-");
13276         gameInfo.black = StrSave("-");
13277         break;
13278
13279       case IcsPlayingWhite:
13280       case IcsPlayingBlack:
13281       case IcsObserving:
13282       case IcsExamining:
13283         break;
13284
13285       case PlayFromGameFile:
13286         gameInfo.event = StrSave("Game from non-PGN file");
13287         gameInfo.site = StrSave(HostName());
13288         gameInfo.date = PGNDate();
13289         gameInfo.round = StrSave("-");
13290         gameInfo.white = StrSave("?");
13291         gameInfo.black = StrSave("?");
13292         break;
13293
13294       default:
13295         break;
13296     }
13297 }
13298
13299 void
13300 ReplaceComment(index, text)
13301      int index;
13302      char *text;
13303 {
13304     int len;
13305
13306     while (*text == '\n') text++;
13307     len = strlen(text);
13308     while (len > 0 && text[len - 1] == '\n') len--;
13309
13310     if (commentList[index] != NULL)
13311       free(commentList[index]);
13312
13313     if (len == 0) {
13314         commentList[index] = NULL;
13315         return;
13316     }
13317   if( *text == '{' && strchr(text, '}') || // [HGM] braces: if certainy malformed, put braces
13318       *text == '[' && strchr(text, ']') || // otherwise hope the user knows what he is doing
13319       *text == '(' && strchr(text, ')')) { // (perhaps check if this parses as comment-only?)
13320     commentList[index] = (char *) malloc(len + 2);
13321     strncpy(commentList[index], text, len);
13322     commentList[index][len] = '\n';
13323     commentList[index][len + 1] = NULLCHAR;
13324   } else {
13325     // [HGM] braces: if text does not start with known OK delimiter, put braces around it.
13326     char *p;
13327     commentList[index] = (char *) malloc(len + 7);
13328     safeStrCpy(commentList[index], "{\n", 3);
13329     safeStrCpy(commentList[index]+2, text, len+1);
13330     commentList[index][len+2] = NULLCHAR;
13331     while(p = strchr(commentList[index], '}')) *p = ')'; // kill all } to make it one comment
13332     strcat(commentList[index], "\n}\n");
13333   }
13334 }
13335
13336 void
13337 CrushCRs(text)
13338      char *text;
13339 {
13340   char *p = text;
13341   char *q = text;
13342   char ch;
13343
13344   do {
13345     ch = *p++;
13346     if (ch == '\r') continue;
13347     *q++ = ch;
13348   } while (ch != '\0');
13349 }
13350
13351 void
13352 AppendComment(index, text, addBraces)
13353      int index;
13354      char *text;
13355      Boolean addBraces; // [HGM] braces: tells if we should add {}
13356 {
13357     int oldlen, len;
13358     char *old;
13359
13360 if(appData.debugMode) fprintf(debugFP, "Append: in='%s' %d\n", text, addBraces); fflush(debugFP);
13361     text = GetInfoFromComment( index, text ); /* [HGM] PV time: strip PV info from comment */
13362
13363     CrushCRs(text);
13364     while (*text == '\n') text++;
13365     len = strlen(text);
13366     while (len > 0 && text[len - 1] == '\n') len--;
13367
13368     if (len == 0) return;
13369
13370     if (commentList[index] != NULL) {
13371         old = commentList[index];
13372         oldlen = strlen(old);
13373         while(commentList[index][oldlen-1] ==  '\n')
13374           commentList[index][--oldlen] = NULLCHAR;
13375         commentList[index] = (char *) malloc(oldlen + len + 6); // might waste 4
13376         safeStrCpy(commentList[index], old, oldlen);
13377         free(old);
13378         // [HGM] braces: join "{A\n}\n" + "{\nB}" as "{A\nB\n}"
13379         if(commentList[index][oldlen-1] == '}' && (text[0] == '{' || addBraces)) {
13380           if(addBraces) addBraces = FALSE; else { text++; len--; }
13381           while (*text == '\n') { text++; len--; }
13382           commentList[index][--oldlen] = NULLCHAR;
13383       }
13384         if(addBraces) strcat(commentList[index], "\n{\n");
13385         else          strcat(commentList[index], "\n");
13386         strcat(commentList[index], text);
13387         if(addBraces) strcat(commentList[index], "\n}\n");
13388         else          strcat(commentList[index], "\n");
13389     } else {
13390         commentList[index] = (char *) malloc(len + 6); // perhaps wastes 4...
13391         if(addBraces)
13392           safeStrCpy(commentList[index], "{\n", 3);
13393         else commentList[index][0] = NULLCHAR;
13394         strcat(commentList[index], text);
13395         strcat(commentList[index], "\n");
13396         if(addBraces) strcat(commentList[index], "}\n");
13397     }
13398 }
13399
13400 static char * FindStr( char * text, char * sub_text )
13401 {
13402     char * result = strstr( text, sub_text );
13403
13404     if( result != NULL ) {
13405         result += strlen( sub_text );
13406     }
13407
13408     return result;
13409 }
13410
13411 /* [AS] Try to extract PV info from PGN comment */
13412 /* [HGM] PV time: and then remove it, to prevent it appearing twice */
13413 char *GetInfoFromComment( int index, char * text )
13414 {
13415     char * sep = text;
13416
13417     if( text != NULL && index > 0 ) {
13418         int score = 0;
13419         int depth = 0;
13420         int time = -1, sec = 0, deci;
13421         char * s_eval = FindStr( text, "[%eval " );
13422         char * s_emt = FindStr( text, "[%emt " );
13423
13424         if( s_eval != NULL || s_emt != NULL ) {
13425             /* New style */
13426             char delim;
13427
13428             if( s_eval != NULL ) {
13429                 if( sscanf( s_eval, "%d,%d%c", &score, &depth, &delim ) != 3 ) {
13430                     return text;
13431                 }
13432
13433                 if( delim != ']' ) {
13434                     return text;
13435                 }
13436             }
13437
13438             if( s_emt != NULL ) {
13439             }
13440                 return text;
13441         }
13442         else {
13443             /* We expect something like: [+|-]nnn.nn/dd */
13444             int score_lo = 0;
13445
13446             if(*text != '{') return text; // [HGM] braces: must be normal comment
13447
13448             sep = strchr( text, '/' );
13449             if( sep == NULL || sep < (text+4) ) {
13450                 return text;
13451             }
13452
13453             time = -1; sec = -1; deci = -1;
13454             if( sscanf( text+1, "%d.%d/%d %d:%d", &score, &score_lo, &depth, &time, &sec ) != 5 &&
13455                 sscanf( text+1, "%d.%d/%d %d.%d", &score, &score_lo, &depth, &time, &deci ) != 5 &&
13456                 sscanf( text+1, "%d.%d/%d %d", &score, &score_lo, &depth, &time ) != 4 &&
13457                 sscanf( text+1, "%d.%d/%d", &score, &score_lo, &depth ) != 3   ) {
13458                 return text;
13459             }
13460
13461             if( score_lo < 0 || score_lo >= 100 ) {
13462                 return text;
13463             }
13464
13465             if(sec >= 0) time = 600*time + 10*sec; else
13466             if(deci >= 0) time = 10*time + deci; else time *= 10; // deci-sec
13467
13468             score = score >= 0 ? score*100 + score_lo : score*100 - score_lo;
13469
13470             /* [HGM] PV time: now locate end of PV info */
13471             while( *++sep >= '0' && *sep <= '9'); // strip depth
13472             if(time >= 0)
13473             while( *++sep >= '0' && *sep <= '9'); // strip time
13474             if(sec >= 0)
13475             while( *++sep >= '0' && *sep <= '9'); // strip seconds
13476             if(deci >= 0)
13477             while( *++sep >= '0' && *sep <= '9'); // strip fractional seconds
13478             while(*sep == ' ') sep++;
13479         }
13480
13481         if( depth <= 0 ) {
13482             return text;
13483         }
13484
13485         if( time < 0 ) {
13486             time = -1;
13487         }
13488
13489         pvInfoList[index-1].depth = depth;
13490         pvInfoList[index-1].score = score;
13491         pvInfoList[index-1].time  = 10*time; // centi-sec
13492         if(*sep == '}') *sep = 0; else *--sep = '{';
13493     }
13494     return sep;
13495 }
13496
13497 void
13498 SendToProgram(message, cps)
13499      char *message;
13500      ChessProgramState *cps;
13501 {
13502     int count, outCount, error;
13503     char buf[MSG_SIZ];
13504
13505     if (cps->pr == NULL) return;
13506     Attention(cps);
13507
13508     if (appData.debugMode) {
13509         TimeMark now;
13510         GetTimeMark(&now);
13511         fprintf(debugFP, "%ld >%-6s: %s",
13512                 SubtractTimeMarks(&now, &programStartTime),
13513                 cps->which, message);
13514     }
13515
13516     count = strlen(message);
13517     outCount = OutputToProcess(cps->pr, message, count, &error);
13518     if (outCount < count && !exiting
13519                          && !endingGame) { /* [HGM] crash: to not hang GameEnds() writing to deceased engines */
13520       snprintf(buf, MSG_SIZ, _("Error writing to %s chess program"), cps->which);
13521         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
13522             if((signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
13523                 gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
13524                 snprintf(buf, MSG_SIZ, "%s program exits in draw position (%s)", cps->which, cps->program);
13525             } else {
13526                 gameInfo.result = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
13527             }
13528             gameInfo.resultDetails = StrSave(buf);
13529         }
13530         if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, error, 1); else errorExitStatus = 1;
13531     }
13532 }
13533
13534 void
13535 ReceiveFromProgram(isr, closure, message, count, error)
13536      InputSourceRef isr;
13537      VOIDSTAR closure;
13538      char *message;
13539      int count;
13540      int error;
13541 {
13542     char *end_str;
13543     char buf[MSG_SIZ];
13544     ChessProgramState *cps = (ChessProgramState *)closure;
13545
13546     if (isr != cps->isr) return; /* Killed intentionally */
13547     if (count <= 0) {
13548         if (count == 0) {
13549             snprintf(buf, MSG_SIZ, _("Error: %s chess program (%s) exited unexpectedly"),
13550                     cps->which, cps->program);
13551         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
13552                 if((signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
13553                     gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
13554                     snprintf(buf, MSG_SIZ, _("%s program exits in draw position (%s)"), cps->which, cps->program);
13555                 } else {
13556                     gameInfo.result = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
13557                 }
13558                 gameInfo.resultDetails = StrSave(buf);
13559             }
13560             RemoveInputSource(cps->isr);
13561             if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, 0, 1); else errorExitStatus = 1;
13562         } else {
13563             snprintf(buf, MSG_SIZ, _("Error reading from %s chess program (%s)"),
13564                     cps->which, cps->program);
13565             RemoveInputSource(cps->isr);
13566
13567             /* [AS] Program is misbehaving badly... kill it */
13568             if( count == -2 ) {
13569                 DestroyChildProcess( cps->pr, 9 );
13570                 cps->pr = NoProc;
13571             }
13572
13573             if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, error, 1); else errorExitStatus = 1;
13574         }
13575         return;
13576     }
13577
13578     if ((end_str = strchr(message, '\r')) != NULL)
13579       *end_str = NULLCHAR;
13580     if ((end_str = strchr(message, '\n')) != NULL)
13581       *end_str = NULLCHAR;
13582
13583     if (appData.debugMode) {
13584         TimeMark now; int print = 1;
13585         char *quote = ""; char c; int i;
13586
13587         if(appData.engineComments != 1) { /* [HGM] debug: decide if protocol-violating output is written */
13588                 char start = message[0];
13589                 if(start >='A' && start <= 'Z') start += 'a' - 'A'; // be tolerant to capitalizing
13590                 if(sscanf(message, "%d%c%d%d%d", &i, &c, &i, &i, &i) != 5 &&
13591                    sscanf(message, "move %c", &c)!=1  && sscanf(message, "offer%c", &c)!=1 &&
13592                    sscanf(message, "resign%c", &c)!=1 && sscanf(message, "feature %c", &c)!=1 &&
13593                    sscanf(message, "error %c", &c)!=1 && sscanf(message, "illegal %c", &c)!=1 &&
13594                    sscanf(message, "tell%c", &c)!=1   && sscanf(message, "0-1 %c", &c)!=1 &&
13595                    sscanf(message, "1-0 %c", &c)!=1   && sscanf(message, "1/2-1/2 %c", &c)!=1 &&
13596                    sscanf(message, "setboard %c", &c)!=1   && sscanf(message, "setup %c", &c)!=1 &&
13597                    sscanf(message, "hint: %c", &c)!=1 &&
13598                    sscanf(message, "pong %c", &c)!=1   && start != '#') {
13599                     quote = appData.engineComments == 2 ? "# " : "### NON-COMPLIANT! ### ";
13600                     print = (appData.engineComments >= 2);
13601                 }
13602                 message[0] = start; // restore original message
13603         }
13604         if(print) {
13605                 GetTimeMark(&now);
13606                 fprintf(debugFP, "%ld <%-6s: %s%s\n",
13607                         SubtractTimeMarks(&now, &programStartTime), cps->which,
13608                         quote,
13609                         message);
13610         }
13611     }
13612
13613     /* [DM] if icsEngineAnalyze is active we block all whisper and kibitz output, because nobody want to see this */
13614     if (appData.icsEngineAnalyze) {
13615         if (strstr(message, "whisper") != NULL ||
13616              strstr(message, "kibitz") != NULL ||
13617             strstr(message, "tellics") != NULL) return;
13618     }
13619
13620     HandleMachineMove(message, cps);
13621 }
13622
13623
13624 void
13625 SendTimeControl(cps, mps, tc, inc, sd, st)
13626      ChessProgramState *cps;
13627      int mps, inc, sd, st;
13628      long tc;
13629 {
13630     char buf[MSG_SIZ];
13631     int seconds;
13632
13633     if( timeControl_2 > 0 ) {
13634         if( (gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b') ) {
13635             tc = timeControl_2;
13636         }
13637     }
13638     tc  /= cps->timeOdds; /* [HGM] time odds: apply before telling engine */
13639     inc /= cps->timeOdds;
13640     st  /= cps->timeOdds;
13641
13642     seconds = (tc / 1000) % 60; /* [HGM] displaced to after applying odds */
13643
13644     if (st > 0) {
13645       /* Set exact time per move, normally using st command */
13646       if (cps->stKludge) {
13647         /* GNU Chess 4 has no st command; uses level in a nonstandard way */
13648         seconds = st % 60;
13649         if (seconds == 0) {
13650           snprintf(buf, MSG_SIZ, "level 1 %d\n", st/60);
13651         } else {
13652           snprintf(buf, MSG_SIZ, "level 1 %d:%02d\n", st/60, seconds);
13653         }
13654       } else {
13655         snprintf(buf, MSG_SIZ, "st %d\n", st);
13656       }
13657     } else {
13658       /* Set conventional or incremental time control, using level command */
13659       if (seconds == 0) {
13660         /* Note old gnuchess bug -- minutes:seconds used to not work.
13661            Fixed in later versions, but still avoid :seconds
13662            when seconds is 0. */
13663         snprintf(buf, MSG_SIZ, "level %d %ld %g\n", mps, tc/60000, inc/1000.);
13664       } else {
13665         snprintf(buf, MSG_SIZ, "level %d %ld:%02d %g\n", mps, tc/60000,
13666                  seconds, inc/1000.);
13667       }
13668     }
13669     SendToProgram(buf, cps);
13670
13671     /* Orthoganally (except for GNU Chess 4), limit time to st seconds */
13672     /* Orthogonally, limit search to given depth */
13673     if (sd > 0) {
13674       if (cps->sdKludge) {
13675         snprintf(buf, MSG_SIZ, "depth\n%d\n", sd);
13676       } else {
13677         snprintf(buf, MSG_SIZ, "sd %d\n", sd);
13678       }
13679       SendToProgram(buf, cps);
13680     }
13681
13682     if(cps->nps > 0) { /* [HGM] nps */
13683         if(cps->supportsNPS == FALSE)
13684           cps->nps = -1; // don't use if engine explicitly says not supported!
13685         else {
13686           snprintf(buf, MSG_SIZ, "nps %d\n", cps->nps);
13687           SendToProgram(buf, cps);
13688         }
13689     }
13690 }
13691
13692 ChessProgramState *WhitePlayer()
13693 /* [HGM] return pointer to 'first' or 'second', depending on who plays white */
13694 {
13695     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b' ||
13696        gameMode == BeginningOfGame || gameMode == MachinePlaysBlack)
13697         return &second;
13698     return &first;
13699 }
13700
13701 void
13702 SendTimeRemaining(cps, machineWhite)
13703      ChessProgramState *cps;
13704      int /*boolean*/ machineWhite;
13705 {
13706     char message[MSG_SIZ];
13707     long time, otime;
13708
13709     /* Note: this routine must be called when the clocks are stopped
13710        or when they have *just* been set or switched; otherwise
13711        it will be off by the time since the current tick started.
13712     */
13713     if (machineWhite) {
13714         time = whiteTimeRemaining / 10;
13715         otime = blackTimeRemaining / 10;
13716     } else {
13717         time = blackTimeRemaining / 10;
13718         otime = whiteTimeRemaining / 10;
13719     }
13720     /* [HGM] translate opponent's time by time-odds factor */
13721     otime = (otime * cps->other->timeOdds) / cps->timeOdds;
13722     if (appData.debugMode) {
13723         fprintf(debugFP, "time odds: %f %f \n", cps->timeOdds, cps->other->timeOdds);
13724     }
13725
13726     if (time <= 0) time = 1;
13727     if (otime <= 0) otime = 1;
13728
13729     snprintf(message, MSG_SIZ, "time %ld\n", time);
13730     SendToProgram(message, cps);
13731
13732     snprintf(message, MSG_SIZ, "otim %ld\n", otime);
13733     SendToProgram(message, cps);
13734 }
13735
13736 int
13737 BoolFeature(p, name, loc, cps)
13738      char **p;
13739      char *name;
13740      int *loc;
13741      ChessProgramState *cps;
13742 {
13743   char buf[MSG_SIZ];
13744   int len = strlen(name);
13745   int val;
13746
13747   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
13748     (*p) += len + 1;
13749     sscanf(*p, "%d", &val);
13750     *loc = (val != 0);
13751     while (**p && **p != ' ')
13752       (*p)++;
13753     snprintf(buf, MSG_SIZ, "accepted %s\n", name);
13754     SendToProgram(buf, cps);
13755     return TRUE;
13756   }
13757   return FALSE;
13758 }
13759
13760 int
13761 IntFeature(p, name, loc, cps)
13762      char **p;
13763      char *name;
13764      int *loc;
13765      ChessProgramState *cps;
13766 {
13767   char buf[MSG_SIZ];
13768   int len = strlen(name);
13769   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
13770     (*p) += len + 1;
13771     sscanf(*p, "%d", loc);
13772     while (**p && **p != ' ') (*p)++;
13773     snprintf(buf, MSG_SIZ, "accepted %s\n", name);
13774     SendToProgram(buf, cps);
13775     return TRUE;
13776   }
13777   return FALSE;
13778 }
13779
13780 int
13781 StringFeature(p, name, loc, cps)
13782      char **p;
13783      char *name;
13784      char loc[];
13785      ChessProgramState *cps;
13786 {
13787   char buf[MSG_SIZ];
13788   int len = strlen(name);
13789   if (strncmp((*p), name, len) == 0
13790       && (*p)[len] == '=' && (*p)[len+1] == '\"') {
13791     (*p) += len + 2;
13792     sscanf(*p, "%[^\"]", loc);
13793     while (**p && **p != '\"') (*p)++;
13794     if (**p == '\"') (*p)++;
13795     snprintf(buf, MSG_SIZ, "accepted %s\n", name);
13796     SendToProgram(buf, cps);
13797     return TRUE;
13798   }
13799   return FALSE;
13800 }
13801
13802 int
13803 ParseOption(Option *opt, ChessProgramState *cps)
13804 // [HGM] options: process the string that defines an engine option, and determine
13805 // name, type, default value, and allowed value range
13806 {
13807         char *p, *q, buf[MSG_SIZ];
13808         int n, min = (-1)<<31, max = 1<<31, def;
13809
13810         if(p = strstr(opt->name, " -spin ")) {
13811             if((n = sscanf(p, " -spin %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
13812             if(max < min) max = min; // enforce consistency
13813             if(def < min) def = min;
13814             if(def > max) def = max;
13815             opt->value = def;
13816             opt->min = min;
13817             opt->max = max;
13818             opt->type = Spin;
13819         } else if((p = strstr(opt->name, " -slider "))) {
13820             // for now -slider is a synonym for -spin, to already provide compatibility with future polyglots
13821             if((n = sscanf(p, " -slider %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
13822             if(max < min) max = min; // enforce consistency
13823             if(def < min) def = min;
13824             if(def > max) def = max;
13825             opt->value = def;
13826             opt->min = min;
13827             opt->max = max;
13828             opt->type = Spin; // Slider;
13829         } else if((p = strstr(opt->name, " -string "))) {
13830             opt->textValue = p+9;
13831             opt->type = TextBox;
13832         } else if((p = strstr(opt->name, " -file "))) {
13833             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
13834             opt->textValue = p+7;
13835             opt->type = TextBox; // FileName;
13836         } else if((p = strstr(opt->name, " -path "))) {
13837             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
13838             opt->textValue = p+7;
13839             opt->type = TextBox; // PathName;
13840         } else if(p = strstr(opt->name, " -check ")) {
13841             if(sscanf(p, " -check %d", &def) < 1) return FALSE;
13842             opt->value = (def != 0);
13843             opt->type = CheckBox;
13844         } else if(p = strstr(opt->name, " -combo ")) {
13845             opt->textValue = (char*) (&cps->comboList[cps->comboCnt]); // cheat with pointer type
13846             cps->comboList[cps->comboCnt++] = q = p+8; // holds possible choices
13847             if(*q == '*') cps->comboList[cps->comboCnt-1]++;
13848             opt->value = n = 0;
13849             while(q = StrStr(q, " /// ")) {
13850                 n++; *q = 0;    // count choices, and null-terminate each of them
13851                 q += 5;
13852                 if(*q == '*') { // remember default, which is marked with * prefix
13853                     q++;
13854                     opt->value = n;
13855                 }
13856                 cps->comboList[cps->comboCnt++] = q;
13857             }
13858             cps->comboList[cps->comboCnt++] = NULL;
13859             opt->max = n + 1;
13860             opt->type = ComboBox;
13861         } else if(p = strstr(opt->name, " -button")) {
13862             opt->type = Button;
13863         } else if(p = strstr(opt->name, " -save")) {
13864             opt->type = SaveButton;
13865         } else return FALSE;
13866         *p = 0; // terminate option name
13867         // now look if the command-line options define a setting for this engine option.
13868         if(cps->optionSettings && cps->optionSettings[0])
13869             p = strstr(cps->optionSettings, opt->name); else p = NULL;
13870         if(p && (p == cps->optionSettings || p[-1] == ',')) {
13871           snprintf(buf, MSG_SIZ, "option %s", p);
13872                 if(p = strstr(buf, ",")) *p = 0;
13873                 if(q = strchr(buf, '=')) switch(opt->type) {
13874                     case ComboBox:
13875                         for(n=0; n<opt->max; n++)
13876                             if(!strcmp(((char**)opt->textValue)[n], q+1)) opt->value = n;
13877                         break;
13878                     case TextBox:
13879                         safeStrCpy(opt->textValue, q+1, MSG_SIZ - (opt->textValue - opt->name));
13880                         break;
13881                     case Spin:
13882                     case CheckBox:
13883                         opt->value = atoi(q+1);
13884                     default:
13885                         break;
13886                 }
13887                 strcat(buf, "\n");
13888                 SendToProgram(buf, cps);
13889         }
13890         return TRUE;
13891 }
13892
13893 void
13894 FeatureDone(cps, val)
13895      ChessProgramState* cps;
13896      int val;
13897 {
13898   DelayedEventCallback cb = GetDelayedEvent();
13899   if ((cb == InitBackEnd3 && cps == &first) ||
13900       (cb == SettingsMenuIfReady && cps == &second) ||
13901       (cb == TwoMachinesEventIfReady && cps == &second)) {
13902     CancelDelayedEvent();
13903     ScheduleDelayedEvent(cb, val ? 1 : 3600000);
13904   }
13905   cps->initDone = val;
13906 }
13907
13908 /* Parse feature command from engine */
13909 void
13910 ParseFeatures(args, cps)
13911      char* args;
13912      ChessProgramState *cps;
13913 {
13914   char *p = args;
13915   char *q;
13916   int val;
13917   char buf[MSG_SIZ];
13918
13919   for (;;) {
13920     while (*p == ' ') p++;
13921     if (*p == NULLCHAR) return;
13922
13923     if (BoolFeature(&p, "setboard", &cps->useSetboard, cps)) continue;
13924     if (BoolFeature(&p, "time", &cps->sendTime, cps)) continue;
13925     if (BoolFeature(&p, "draw", &cps->sendDrawOffers, cps)) continue;
13926     if (BoolFeature(&p, "sigint", &cps->useSigint, cps)) continue;
13927     if (BoolFeature(&p, "sigterm", &cps->useSigterm, cps)) continue;
13928     if (BoolFeature(&p, "reuse", &val, cps)) {
13929       /* Engine can disable reuse, but can't enable it if user said no */
13930       if (!val) cps->reuse = FALSE;
13931       continue;
13932     }
13933     if (BoolFeature(&p, "analyze", &cps->analysisSupport, cps)) continue;
13934     if (StringFeature(&p, "myname", &cps->tidy, cps)) {
13935       if (gameMode == TwoMachinesPlay) {
13936         DisplayTwoMachinesTitle();
13937       } else {
13938         DisplayTitle("");
13939       }
13940       continue;
13941     }
13942     if (StringFeature(&p, "variants", &cps->variants, cps)) continue;
13943     if (BoolFeature(&p, "san", &cps->useSAN, cps)) continue;
13944     if (BoolFeature(&p, "ping", &cps->usePing, cps)) continue;
13945     if (BoolFeature(&p, "playother", &cps->usePlayother, cps)) continue;
13946     if (BoolFeature(&p, "colors", &cps->useColors, cps)) continue;
13947     if (BoolFeature(&p, "usermove", &cps->useUsermove, cps)) continue;
13948     if (BoolFeature(&p, "ics", &cps->sendICS, cps)) continue;
13949     if (BoolFeature(&p, "name", &cps->sendName, cps)) continue;
13950     if (BoolFeature(&p, "pause", &val, cps)) continue; /* unused at present */
13951     if (IntFeature(&p, "done", &val, cps)) {
13952       FeatureDone(cps, val);
13953       continue;
13954     }
13955     /* Added by Tord: */
13956     if (BoolFeature(&p, "fen960", &cps->useFEN960, cps)) continue;
13957     if (BoolFeature(&p, "oocastle", &cps->useOOCastle, cps)) continue;
13958     /* End of additions by Tord */
13959
13960     /* [HGM] added features: */
13961     if (BoolFeature(&p, "debug", &cps->debug, cps)) continue;
13962     if (BoolFeature(&p, "nps", &cps->supportsNPS, cps)) continue;
13963     if (IntFeature(&p, "level", &cps->maxNrOfSessions, cps)) continue;
13964     if (BoolFeature(&p, "memory", &cps->memSize, cps)) continue;
13965     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
13966     if (StringFeature(&p, "egt", &cps->egtFormats, cps)) continue;
13967     if (StringFeature(&p, "option", &(cps->option[cps->nrOptions].name), cps)) {
13968         if(!ParseOption(&(cps->option[cps->nrOptions++]), cps)) { // [HGM] options: add option feature
13969           snprintf(buf, MSG_SIZ, "rejected option %s\n", cps->option[--cps->nrOptions].name);
13970             SendToProgram(buf, cps);
13971             continue;
13972         }
13973         if(cps->nrOptions >= MAX_OPTIONS) {
13974             cps->nrOptions--;
13975             snprintf(buf, MSG_SIZ, "%s engine has too many options\n", cps->which);
13976             DisplayError(buf, 0);
13977         }
13978         continue;
13979     }
13980     /* End of additions by HGM */
13981
13982     /* unknown feature: complain and skip */
13983     q = p;
13984     while (*q && *q != '=') q++;
13985     snprintf(buf, MSG_SIZ,"rejected %.*s\n", (int)(q-p), p);
13986     SendToProgram(buf, cps);
13987     p = q;
13988     if (*p == '=') {
13989       p++;
13990       if (*p == '\"') {
13991         p++;
13992         while (*p && *p != '\"') p++;
13993         if (*p == '\"') p++;
13994       } else {
13995         while (*p && *p != ' ') p++;
13996       }
13997     }
13998   }
13999
14000 }
14001
14002 void
14003 PeriodicUpdatesEvent(newState)
14004      int newState;
14005 {
14006     if (newState == appData.periodicUpdates)
14007       return;
14008
14009     appData.periodicUpdates=newState;
14010
14011     /* Display type changes, so update it now */
14012 //    DisplayAnalysis();
14013
14014     /* Get the ball rolling again... */
14015     if (newState) {
14016         AnalysisPeriodicEvent(1);
14017         StartAnalysisClock();
14018     }
14019 }
14020
14021 void
14022 PonderNextMoveEvent(newState)
14023      int newState;
14024 {
14025     if (newState == appData.ponderNextMove) return;
14026     if (gameMode == EditPosition) EditPositionDone(TRUE);
14027     if (newState) {
14028         SendToProgram("hard\n", &first);
14029         if (gameMode == TwoMachinesPlay) {
14030             SendToProgram("hard\n", &second);
14031         }
14032     } else {
14033         SendToProgram("easy\n", &first);
14034         thinkOutput[0] = NULLCHAR;
14035         if (gameMode == TwoMachinesPlay) {
14036             SendToProgram("easy\n", &second);
14037         }
14038     }
14039     appData.ponderNextMove = newState;
14040 }
14041
14042 void
14043 NewSettingEvent(option, feature, command, value)
14044      char *command;
14045      int option, value, *feature;
14046 {
14047     char buf[MSG_SIZ];
14048
14049     if (gameMode == EditPosition) EditPositionDone(TRUE);
14050     snprintf(buf, MSG_SIZ,"%s%s %d\n", (option ? "option ": ""), command, value);
14051     if(feature == NULL || *feature) SendToProgram(buf, &first);
14052     if (gameMode == TwoMachinesPlay) {
14053         if(feature == NULL || feature[(int*)&second - (int*)&first]) SendToProgram(buf, &second);
14054     }
14055 }
14056
14057 void
14058 ShowThinkingEvent()
14059 // [HGM] thinking: this routine is now also called from "Options -> Engine..." popup
14060 {
14061     static int oldState = 2; // kludge alert! Neither true nor fals, so first time oldState is always updated
14062     int newState = appData.showThinking
14063         // [HGM] thinking: other features now need thinking output as well
14064         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp();
14065
14066     if (oldState == newState) return;
14067     oldState = newState;
14068     if (gameMode == EditPosition) EditPositionDone(TRUE);
14069     if (oldState) {
14070         SendToProgram("post\n", &first);
14071         if (gameMode == TwoMachinesPlay) {
14072             SendToProgram("post\n", &second);
14073         }
14074     } else {
14075         SendToProgram("nopost\n", &first);
14076         thinkOutput[0] = NULLCHAR;
14077         if (gameMode == TwoMachinesPlay) {
14078             SendToProgram("nopost\n", &second);
14079         }
14080     }
14081 //    appData.showThinking = newState; // [HGM] thinking: responsible option should already have be changed when calling this routine!
14082 }
14083
14084 void
14085 AskQuestionEvent(title, question, replyPrefix, which)
14086      char *title; char *question; char *replyPrefix; char *which;
14087 {
14088   ProcRef pr = (which[0] == '1') ? first.pr : second.pr;
14089   if (pr == NoProc) return;
14090   AskQuestion(title, question, replyPrefix, pr);
14091 }
14092
14093 void
14094 DisplayMove(moveNumber)
14095      int moveNumber;
14096 {
14097     char message[MSG_SIZ];
14098     char res[MSG_SIZ];
14099     char cpThinkOutput[MSG_SIZ];
14100
14101     if(appData.noGUI) return; // [HGM] fast: suppress display of moves
14102
14103     if (moveNumber == forwardMostMove - 1 ||
14104         gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
14105
14106         safeStrCpy(cpThinkOutput, thinkOutput, sizeof(cpThinkOutput)/sizeof(cpThinkOutput[0]));
14107
14108         if (strchr(cpThinkOutput, '\n')) {
14109             *strchr(cpThinkOutput, '\n') = NULLCHAR;
14110         }
14111     } else {
14112         *cpThinkOutput = NULLCHAR;
14113     }
14114
14115     /* [AS] Hide thinking from human user */
14116     if( appData.hideThinkingFromHuman && gameMode != TwoMachinesPlay ) {
14117         *cpThinkOutput = NULLCHAR;
14118         if( thinkOutput[0] != NULLCHAR ) {
14119             int i;
14120
14121             for( i=0; i<=hiddenThinkOutputState; i++ ) {
14122                 cpThinkOutput[i] = '.';
14123             }
14124             cpThinkOutput[i] = NULLCHAR;
14125             hiddenThinkOutputState = (hiddenThinkOutputState + 1) % 3;
14126         }
14127     }
14128
14129     if (moveNumber == forwardMostMove - 1 &&
14130         gameInfo.resultDetails != NULL) {
14131         if (gameInfo.resultDetails[0] == NULLCHAR) {
14132           snprintf(res, MSG_SIZ, " %s", PGNResult(gameInfo.result));
14133         } else {
14134           snprintf(res, MSG_SIZ, " {%s} %s",
14135                     T_(gameInfo.resultDetails), PGNResult(gameInfo.result));
14136         }
14137     } else {
14138         res[0] = NULLCHAR;
14139     }
14140
14141     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
14142         DisplayMessage(res, cpThinkOutput);
14143     } else {
14144       snprintf(message, MSG_SIZ, "%d.%s%s%s", moveNumber / 2 + 1,
14145                 WhiteOnMove(moveNumber) ? " " : ".. ",
14146                 parseList[moveNumber], res);
14147         DisplayMessage(message, cpThinkOutput);
14148     }
14149 }
14150
14151 void
14152 DisplayComment(moveNumber, text)
14153      int moveNumber;
14154      char *text;
14155 {
14156     char title[MSG_SIZ];
14157     char buf[8000]; // comment can be long!
14158     int score, depth;
14159
14160     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
14161       safeStrCpy(title, "Comment", sizeof(title)/sizeof(title[0]));
14162     } else {
14163       snprintf(title,MSG_SIZ, "Comment on %d.%s%s", moveNumber / 2 + 1,
14164               WhiteOnMove(moveNumber) ? " " : ".. ",
14165               parseList[moveNumber]);
14166     }
14167     // [HGM] PV info: display PV info together with (or as) comment
14168     if(moveNumber >= 0 && (depth = pvInfoList[moveNumber].depth) > 0) {
14169       if(text == NULL) text = "";
14170       score = pvInfoList[moveNumber].score;
14171       snprintf(buf,sizeof(buf)/sizeof(buf[0]), "%s%.2f/%d %d\n%s", score>0 ? "+" : "", score/100.,
14172               depth, (pvInfoList[moveNumber].time+50)/100, text);
14173       text = buf;
14174     }
14175     if (text != NULL && (appData.autoDisplayComment || commentUp))
14176         CommentPopUp(title, text);
14177 }
14178
14179 /* This routine sends a ^C interrupt to gnuchess, to awaken it if it
14180  * might be busy thinking or pondering.  It can be omitted if your
14181  * gnuchess is configured to stop thinking immediately on any user
14182  * input.  However, that gnuchess feature depends on the FIONREAD
14183  * ioctl, which does not work properly on some flavors of Unix.
14184  */
14185 void
14186 Attention(cps)
14187      ChessProgramState *cps;
14188 {
14189 #if ATTENTION
14190     if (!cps->useSigint) return;
14191     if (appData.noChessProgram || (cps->pr == NoProc)) return;
14192     switch (gameMode) {
14193       case MachinePlaysWhite:
14194       case MachinePlaysBlack:
14195       case TwoMachinesPlay:
14196       case IcsPlayingWhite:
14197       case IcsPlayingBlack:
14198       case AnalyzeMode:
14199       case AnalyzeFile:
14200         /* Skip if we know it isn't thinking */
14201         if (!cps->maybeThinking) return;
14202         if (appData.debugMode)
14203           fprintf(debugFP, "Interrupting %s\n", cps->which);
14204         InterruptChildProcess(cps->pr);
14205         cps->maybeThinking = FALSE;
14206         break;
14207       default:
14208         break;
14209     }
14210 #endif /*ATTENTION*/
14211 }
14212
14213 int
14214 CheckFlags()
14215 {
14216     if (whiteTimeRemaining <= 0) {
14217         if (!whiteFlag) {
14218             whiteFlag = TRUE;
14219             if (appData.icsActive) {
14220                 if (appData.autoCallFlag &&
14221                     gameMode == IcsPlayingBlack && !blackFlag) {
14222                   SendToICS(ics_prefix);
14223                   SendToICS("flag\n");
14224                 }
14225             } else {
14226                 if (blackFlag) {
14227                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
14228                 } else {
14229                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("White's flag fell"));
14230                     if (appData.autoCallFlag) {
14231                         GameEnds(BlackWins, "Black wins on time", GE_XBOARD);
14232                         return TRUE;
14233                     }
14234                 }
14235             }
14236         }
14237     }
14238     if (blackTimeRemaining <= 0) {
14239         if (!blackFlag) {
14240             blackFlag = TRUE;
14241             if (appData.icsActive) {
14242                 if (appData.autoCallFlag &&
14243                     gameMode == IcsPlayingWhite && !whiteFlag) {
14244                   SendToICS(ics_prefix);
14245                   SendToICS("flag\n");
14246                 }
14247             } else {
14248                 if (whiteFlag) {
14249                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
14250                 } else {
14251                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Black's flag fell"));
14252                     if (appData.autoCallFlag) {
14253                         GameEnds(WhiteWins, "White wins on time", GE_XBOARD);
14254                         return TRUE;
14255                     }
14256                 }
14257             }
14258         }
14259     }
14260     return FALSE;
14261 }
14262
14263 void
14264 CheckTimeControl()
14265 {
14266     if (!appData.clockMode || appData.icsActive || searchTime || // [HGM] st: no inc in st mode
14267         gameMode == PlayFromGameFile || forwardMostMove == 0) return;
14268
14269     /*
14270      * add time to clocks when time control is achieved ([HGM] now also used for increment)
14271      */
14272     if ( !WhiteOnMove(forwardMostMove) ) {
14273         /* White made time control */
14274         lastWhite -= whiteTimeRemaining; // [HGM] contains start time, socalculate thinking time
14275         whiteTimeRemaining += GetTimeQuota((forwardMostMove-whiteStartMove-1)/2, lastWhite, whiteTC)
14276         /* [HGM] time odds: correct new time quota for time odds! */
14277                                             / WhitePlayer()->timeOdds;
14278         lastBlack = blackTimeRemaining; // [HGM] leave absolute time (after quota), so next switch we can us it to calculate thinking time
14279     } else {
14280         lastBlack -= blackTimeRemaining;
14281         /* Black made time control */
14282         blackTimeRemaining += GetTimeQuota((forwardMostMove-blackStartMove-1)/2, lastBlack, blackTC)
14283                                             / WhitePlayer()->other->timeOdds;
14284         lastWhite = whiteTimeRemaining;
14285     }
14286 }
14287
14288 void
14289 DisplayBothClocks()
14290 {
14291     int wom = gameMode == EditPosition ?
14292       !blackPlaysFirst : WhiteOnMove(currentMove);
14293     DisplayWhiteClock(whiteTimeRemaining, wom);
14294     DisplayBlackClock(blackTimeRemaining, !wom);
14295 }
14296
14297
14298 /* Timekeeping seems to be a portability nightmare.  I think everyone
14299    has ftime(), but I'm really not sure, so I'm including some ifdefs
14300    to use other calls if you don't.  Clocks will be less accurate if
14301    you have neither ftime nor gettimeofday.
14302 */
14303
14304 /* VS 2008 requires the #include outside of the function */
14305 #if !HAVE_GETTIMEOFDAY && HAVE_FTIME
14306 #include <sys/timeb.h>
14307 #endif
14308
14309 /* Get the current time as a TimeMark */
14310 void
14311 GetTimeMark(tm)
14312      TimeMark *tm;
14313 {
14314 #if HAVE_GETTIMEOFDAY
14315
14316     struct timeval timeVal;
14317     struct timezone timeZone;
14318
14319     gettimeofday(&timeVal, &timeZone);
14320     tm->sec = (long) timeVal.tv_sec;
14321     tm->ms = (int) (timeVal.tv_usec / 1000L);
14322
14323 #else /*!HAVE_GETTIMEOFDAY*/
14324 #if HAVE_FTIME
14325
14326 // include <sys/timeb.h> / moved to just above start of function
14327     struct timeb timeB;
14328
14329     ftime(&timeB);
14330     tm->sec = (long) timeB.time;
14331     tm->ms = (int) timeB.millitm;
14332
14333 #else /*!HAVE_FTIME && !HAVE_GETTIMEOFDAY*/
14334     tm->sec = (long) time(NULL);
14335     tm->ms = 0;
14336 #endif
14337 #endif
14338 }
14339
14340 /* Return the difference in milliseconds between two
14341    time marks.  We assume the difference will fit in a long!
14342 */
14343 long
14344 SubtractTimeMarks(tm2, tm1)
14345      TimeMark *tm2, *tm1;
14346 {
14347     return 1000L*(tm2->sec - tm1->sec) +
14348            (long) (tm2->ms - tm1->ms);
14349 }
14350
14351
14352 /*
14353  * Code to manage the game clocks.
14354  *
14355  * In tournament play, black starts the clock and then white makes a move.
14356  * We give the human user a slight advantage if he is playing white---the
14357  * clocks don't run until he makes his first move, so it takes zero time.
14358  * Also, we don't account for network lag, so we could get out of sync
14359  * with GNU Chess's clock -- but then, referees are always right.
14360  */
14361
14362 static TimeMark tickStartTM;
14363 static long intendedTickLength;
14364
14365 long
14366 NextTickLength(timeRemaining)
14367      long timeRemaining;
14368 {
14369     long nominalTickLength, nextTickLength;
14370
14371     if (timeRemaining > 0L && timeRemaining <= 10000L)
14372       nominalTickLength = 100L;
14373     else
14374       nominalTickLength = 1000L;
14375     nextTickLength = timeRemaining % nominalTickLength;
14376     if (nextTickLength <= 0) nextTickLength += nominalTickLength;
14377
14378     return nextTickLength;
14379 }
14380
14381 /* Adjust clock one minute up or down */
14382 void
14383 AdjustClock(Boolean which, int dir)
14384 {
14385     if(which) blackTimeRemaining += 60000*dir;
14386     else      whiteTimeRemaining += 60000*dir;
14387     DisplayBothClocks();
14388 }
14389
14390 /* Stop clocks and reset to a fresh time control */
14391 void
14392 ResetClocks()
14393 {
14394     (void) StopClockTimer();
14395     if (appData.icsActive) {
14396         whiteTimeRemaining = blackTimeRemaining = 0;
14397     } else if (searchTime) {
14398         whiteTimeRemaining = 1000*searchTime / WhitePlayer()->timeOdds;
14399         blackTimeRemaining = 1000*searchTime / WhitePlayer()->other->timeOdds;
14400     } else { /* [HGM] correct new time quote for time odds */
14401         whiteTC = blackTC = fullTimeControlString;
14402         whiteTimeRemaining = GetTimeQuota(-1, 0, whiteTC) / WhitePlayer()->timeOdds;
14403         blackTimeRemaining = GetTimeQuota(-1, 0, blackTC) / WhitePlayer()->other->timeOdds;
14404     }
14405     if (whiteFlag || blackFlag) {
14406         DisplayTitle("");
14407         whiteFlag = blackFlag = FALSE;
14408     }
14409     lastWhite = lastBlack = whiteStartMove = blackStartMove = 0;
14410     DisplayBothClocks();
14411 }
14412
14413 #define FUDGE 25 /* 25ms = 1/40 sec; should be plenty even for 50 Hz clocks */
14414
14415 /* Decrement running clock by amount of time that has passed */
14416 void
14417 DecrementClocks()
14418 {
14419     long timeRemaining;
14420     long lastTickLength, fudge;
14421     TimeMark now;
14422
14423     if (!appData.clockMode) return;
14424     if (gameMode==AnalyzeMode || gameMode == AnalyzeFile) return;
14425
14426     GetTimeMark(&now);
14427
14428     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
14429
14430     /* Fudge if we woke up a little too soon */
14431     fudge = intendedTickLength - lastTickLength;
14432     if (fudge < 0 || fudge > FUDGE) fudge = 0;
14433
14434     if (WhiteOnMove(forwardMostMove)) {
14435         if(whiteNPS >= 0) lastTickLength = 0;
14436         timeRemaining = whiteTimeRemaining -= lastTickLength;
14437         if(timeRemaining < 0 && !appData.icsActive) {
14438             GetTimeQuota((forwardMostMove-whiteStartMove-1)/2, 0, whiteTC); // sets suddenDeath & nextSession;
14439             if(suddenDeath) { // [HGM] if we run out of a non-last incremental session, go to the next
14440                 whiteStartMove = forwardMostMove; whiteTC = nextSession;
14441                 lastWhite= timeRemaining = whiteTimeRemaining += GetTimeQuota(-1, 0, whiteTC);
14442             }
14443         }
14444         DisplayWhiteClock(whiteTimeRemaining - fudge,
14445                           WhiteOnMove(currentMove < forwardMostMove ? currentMove : forwardMostMove));
14446     } else {
14447         if(blackNPS >= 0) lastTickLength = 0;
14448         timeRemaining = blackTimeRemaining -= lastTickLength;
14449         if(timeRemaining < 0 && !appData.icsActive) { // [HGM] if we run out of a non-last incremental session, go to the next
14450             GetTimeQuota((forwardMostMove-blackStartMove-1)/2, 0, blackTC);
14451             if(suddenDeath) {
14452                 blackStartMove = forwardMostMove;
14453                 lastBlack = timeRemaining = blackTimeRemaining += GetTimeQuota(-1, 0, blackTC=nextSession);
14454             }
14455         }
14456         DisplayBlackClock(blackTimeRemaining - fudge,
14457                           !WhiteOnMove(currentMove < forwardMostMove ? currentMove : forwardMostMove));
14458     }
14459     if (CheckFlags()) return;
14460
14461     tickStartTM = now;
14462     intendedTickLength = NextTickLength(timeRemaining - fudge) + fudge;
14463     StartClockTimer(intendedTickLength);
14464
14465     /* if the time remaining has fallen below the alarm threshold, sound the
14466      * alarm. if the alarm has sounded and (due to a takeback or time control
14467      * with increment) the time remaining has increased to a level above the
14468      * threshold, reset the alarm so it can sound again.
14469      */
14470
14471     if (appData.icsActive && appData.icsAlarm) {
14472
14473         /* make sure we are dealing with the user's clock */
14474         if (!( ((gameMode == IcsPlayingWhite) && WhiteOnMove(currentMove)) ||
14475                ((gameMode == IcsPlayingBlack) && !WhiteOnMove(currentMove))
14476            )) return;
14477
14478         if (alarmSounded && (timeRemaining > appData.icsAlarmTime)) {
14479             alarmSounded = FALSE;
14480         } else if (!alarmSounded && (timeRemaining <= appData.icsAlarmTime)) {
14481             PlayAlarmSound();
14482             alarmSounded = TRUE;
14483         }
14484     }
14485 }
14486
14487
14488 /* A player has just moved, so stop the previously running
14489    clock and (if in clock mode) start the other one.
14490    We redisplay both clocks in case we're in ICS mode, because
14491    ICS gives us an update to both clocks after every move.
14492    Note that this routine is called *after* forwardMostMove
14493    is updated, so the last fractional tick must be subtracted
14494    from the color that is *not* on move now.
14495 */
14496 void
14497 SwitchClocks(int newMoveNr)
14498 {
14499     long lastTickLength;
14500     TimeMark now;
14501     int flagged = FALSE;
14502
14503     GetTimeMark(&now);
14504
14505     if (StopClockTimer() && appData.clockMode) {
14506         lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
14507         if (!WhiteOnMove(forwardMostMove)) {
14508             if(blackNPS >= 0) lastTickLength = 0;
14509             blackTimeRemaining -= lastTickLength;
14510            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
14511 //         if(pvInfoList[forwardMostMove-1].time == -1)
14512                  pvInfoList[forwardMostMove-1].time =               // use GUI time
14513                       (timeRemaining[1][forwardMostMove-1] - blackTimeRemaining)/10;
14514         } else {
14515            if(whiteNPS >= 0) lastTickLength = 0;
14516            whiteTimeRemaining -= lastTickLength;
14517            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
14518 //         if(pvInfoList[forwardMostMove-1].time == -1)
14519                  pvInfoList[forwardMostMove-1].time =
14520                       (timeRemaining[0][forwardMostMove-1] - whiteTimeRemaining)/10;
14521         }
14522         flagged = CheckFlags();
14523     }
14524     forwardMostMove = newMoveNr; // [HGM] race: change stm when no timer interrupt scheduled
14525     CheckTimeControl();
14526
14527     if (flagged || !appData.clockMode) return;
14528
14529     switch (gameMode) {
14530       case MachinePlaysBlack:
14531       case MachinePlaysWhite:
14532       case BeginningOfGame:
14533         if (pausing) return;
14534         break;
14535
14536       case EditGame:
14537       case PlayFromGameFile:
14538       case IcsExamining:
14539         return;
14540
14541       default:
14542         break;
14543     }
14544
14545     if (searchTime) { // [HGM] st: set clock of player that has to move to max time
14546         if(WhiteOnMove(forwardMostMove))
14547              whiteTimeRemaining = 1000*searchTime / WhitePlayer()->timeOdds;
14548         else blackTimeRemaining = 1000*searchTime / WhitePlayer()->other->timeOdds;
14549     }
14550
14551     tickStartTM = now;
14552     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
14553       whiteTimeRemaining : blackTimeRemaining);
14554     StartClockTimer(intendedTickLength);
14555 }
14556
14557
14558 /* Stop both clocks */
14559 void
14560 StopClocks()
14561 {
14562     long lastTickLength;
14563     TimeMark now;
14564
14565     if (!StopClockTimer()) return;
14566     if (!appData.clockMode) return;
14567
14568     GetTimeMark(&now);
14569
14570     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
14571     if (WhiteOnMove(forwardMostMove)) {
14572         if(whiteNPS >= 0) lastTickLength = 0;
14573         whiteTimeRemaining -= lastTickLength;
14574         DisplayWhiteClock(whiteTimeRemaining, WhiteOnMove(currentMove));
14575     } else {
14576         if(blackNPS >= 0) lastTickLength = 0;
14577         blackTimeRemaining -= lastTickLength;
14578         DisplayBlackClock(blackTimeRemaining, !WhiteOnMove(currentMove));
14579     }
14580     CheckFlags();
14581 }
14582
14583 /* Start clock of player on move.  Time may have been reset, so
14584    if clock is already running, stop and restart it. */
14585 void
14586 StartClocks()
14587 {
14588     (void) StopClockTimer(); /* in case it was running already */
14589     DisplayBothClocks();
14590     if (CheckFlags()) return;
14591
14592     if (!appData.clockMode) return;
14593     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) return;
14594
14595     GetTimeMark(&tickStartTM);
14596     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
14597       whiteTimeRemaining : blackTimeRemaining);
14598
14599    /* [HGM] nps: figure out nps factors, by determining which engine plays white and/or black once and for all */
14600     whiteNPS = blackNPS = -1;
14601     if(gameMode == MachinePlaysWhite || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w'
14602        || appData.zippyPlay && gameMode == IcsPlayingBlack) // first (perhaps only) engine has white
14603         whiteNPS = first.nps;
14604     if(gameMode == MachinePlaysBlack || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b'
14605        || appData.zippyPlay && gameMode == IcsPlayingWhite) // first (perhaps only) engine has black
14606         blackNPS = first.nps;
14607     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b') // second only used in Two-Machines mode
14608         whiteNPS = second.nps;
14609     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w')
14610         blackNPS = second.nps;
14611     if(appData.debugMode) fprintf(debugFP, "nps: w=%d, b=%d\n", whiteNPS, blackNPS);
14612
14613     StartClockTimer(intendedTickLength);
14614 }
14615
14616 char *
14617 TimeString(ms)
14618      long ms;
14619 {
14620     long second, minute, hour, day;
14621     char *sign = "";
14622     static char buf[32];
14623
14624     if (ms > 0 && ms <= 9900) {
14625       /* convert milliseconds to tenths, rounding up */
14626       double tenths = floor( ((double)(ms + 99L)) / 100.00 );
14627
14628       snprintf(buf,sizeof(buf)/sizeof(buf[0]), " %03.1f ", tenths/10.0);
14629       return buf;
14630     }
14631
14632     /* convert milliseconds to seconds, rounding up */
14633     /* use floating point to avoid strangeness of integer division
14634        with negative dividends on many machines */
14635     second = (long) floor(((double) (ms + 999L)) / 1000.0);
14636
14637     if (second < 0) {
14638         sign = "-";
14639         second = -second;
14640     }
14641
14642     day = second / (60 * 60 * 24);
14643     second = second % (60 * 60 * 24);
14644     hour = second / (60 * 60);
14645     second = second % (60 * 60);
14646     minute = second / 60;
14647     second = second % 60;
14648
14649     if (day > 0)
14650       snprintf(buf, sizeof(buf)/sizeof(buf[0]), " %s%ld:%02ld:%02ld:%02ld ",
14651               sign, day, hour, minute, second);
14652     else if (hour > 0)
14653       snprintf(buf, sizeof(buf)/sizeof(buf[0]), " %s%ld:%02ld:%02ld ", sign, hour, minute, second);
14654     else
14655       snprintf(buf, sizeof(buf)/sizeof(buf[0]), " %s%2ld:%02ld ", sign, minute, second);
14656
14657     return buf;
14658 }
14659
14660
14661 /*
14662  * This is necessary because some C libraries aren't ANSI C compliant yet.
14663  */
14664 char *
14665 StrStr(string, match)
14666      char *string, *match;
14667 {
14668     int i, length;
14669
14670     length = strlen(match);
14671
14672     for (i = strlen(string) - length; i >= 0; i--, string++)
14673       if (!strncmp(match, string, length))
14674         return string;
14675
14676     return NULL;
14677 }
14678
14679 char *
14680 StrCaseStr(string, match)
14681      char *string, *match;
14682 {
14683     int i, j, length;
14684
14685     length = strlen(match);
14686
14687     for (i = strlen(string) - length; i >= 0; i--, string++) {
14688         for (j = 0; j < length; j++) {
14689             if (ToLower(match[j]) != ToLower(string[j]))
14690               break;
14691         }
14692         if (j == length) return string;
14693     }
14694
14695     return NULL;
14696 }
14697
14698 #ifndef _amigados
14699 int
14700 StrCaseCmp(s1, s2)
14701      char *s1, *s2;
14702 {
14703     char c1, c2;
14704
14705     for (;;) {
14706         c1 = ToLower(*s1++);
14707         c2 = ToLower(*s2++);
14708         if (c1 > c2) return 1;
14709         if (c1 < c2) return -1;
14710         if (c1 == NULLCHAR) return 0;
14711     }
14712 }
14713
14714
14715 int
14716 ToLower(c)
14717      int c;
14718 {
14719     return isupper(c) ? tolower(c) : c;
14720 }
14721
14722
14723 int
14724 ToUpper(c)
14725      int c;
14726 {
14727     return islower(c) ? toupper(c) : c;
14728 }
14729 #endif /* !_amigados    */
14730
14731 char *
14732 StrSave(s)
14733      char *s;
14734 {
14735   char *ret;
14736
14737   if ((ret = (char *) malloc(strlen(s) + 1)))
14738     {
14739       safeStrCpy(ret, s, strlen(s)+1);
14740     }
14741   return ret;
14742 }
14743
14744 char *
14745 StrSavePtr(s, savePtr)
14746      char *s, **savePtr;
14747 {
14748     if (*savePtr) {
14749         free(*savePtr);
14750     }
14751     if ((*savePtr = (char *) malloc(strlen(s) + 1))) {
14752       safeStrCpy(*savePtr, s, strlen(s)+1);
14753     }
14754     return(*savePtr);
14755 }
14756
14757 char *
14758 PGNDate()
14759 {
14760     time_t clock;
14761     struct tm *tm;
14762     char buf[MSG_SIZ];
14763
14764     clock = time((time_t *)NULL);
14765     tm = localtime(&clock);
14766     snprintf(buf, MSG_SIZ, "%04d.%02d.%02d",
14767             tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
14768     return StrSave(buf);
14769 }
14770
14771
14772 char *
14773 PositionToFEN(move, overrideCastling)
14774      int move;
14775      char *overrideCastling;
14776 {
14777     int i, j, fromX, fromY, toX, toY;
14778     int whiteToPlay;
14779     char buf[128];
14780     char *p, *q;
14781     int emptycount;
14782     ChessSquare piece;
14783
14784     whiteToPlay = (gameMode == EditPosition) ?
14785       !blackPlaysFirst : (move % 2 == 0);
14786     p = buf;
14787
14788     /* Piece placement data */
14789     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
14790         emptycount = 0;
14791         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
14792             if (boards[move][i][j] == EmptySquare) {
14793                 emptycount++;
14794             } else { ChessSquare piece = boards[move][i][j];
14795                 if (emptycount > 0) {
14796                     if(emptycount<10) /* [HGM] can be >= 10 */
14797                         *p++ = '0' + emptycount;
14798                     else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
14799                     emptycount = 0;
14800                 }
14801                 if(PieceToChar(piece) == '+') {
14802                     /* [HGM] write promoted pieces as '+<unpromoted>' (Shogi) */
14803                     *p++ = '+';
14804                     piece = (ChessSquare)(DEMOTED piece);
14805                 }
14806                 *p++ = PieceToChar(piece);
14807                 if(p[-1] == '~') {
14808                     /* [HGM] flag promoted pieces as '<promoted>~' (Crazyhouse) */
14809                     p[-1] = PieceToChar((ChessSquare)(DEMOTED piece));
14810                     *p++ = '~';
14811                 }
14812             }
14813         }
14814         if (emptycount > 0) {
14815             if(emptycount<10) /* [HGM] can be >= 10 */
14816                 *p++ = '0' + emptycount;
14817             else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
14818             emptycount = 0;
14819         }
14820         *p++ = '/';
14821     }
14822     *(p - 1) = ' ';
14823
14824     /* [HGM] print Crazyhouse or Shogi holdings */
14825     if( gameInfo.holdingsWidth ) {
14826         *(p-1) = '['; /* if we wanted to support BFEN, this could be '/' */
14827         q = p;
14828         for(i=0; i<gameInfo.holdingsSize; i++) { /* white holdings */
14829             piece = boards[move][i][BOARD_WIDTH-1];
14830             if( piece != EmptySquare )
14831               for(j=0; j<(int) boards[move][i][BOARD_WIDTH-2]; j++)
14832                   *p++ = PieceToChar(piece);
14833         }
14834         for(i=0; i<gameInfo.holdingsSize; i++) { /* black holdings */
14835             piece = boards[move][BOARD_HEIGHT-i-1][0];
14836             if( piece != EmptySquare )
14837               for(j=0; j<(int) boards[move][BOARD_HEIGHT-i-1][1]; j++)
14838                   *p++ = PieceToChar(piece);
14839         }
14840
14841         if( q == p ) *p++ = '-';
14842         *p++ = ']';
14843         *p++ = ' ';
14844     }
14845
14846     /* Active color */
14847     *p++ = whiteToPlay ? 'w' : 'b';
14848     *p++ = ' ';
14849
14850   if(q = overrideCastling) { // [HGM] FRC: override castling & e.p fields for non-compliant engines
14851     while(*p++ = *q++); if(q != overrideCastling+1) p[-1] = ' '; else --p;
14852   } else {
14853   if(nrCastlingRights) {
14854      q = p;
14855      if(gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) {
14856        /* [HGM] write directly from rights */
14857            if(boards[move][CASTLING][2] != NoRights &&
14858               boards[move][CASTLING][0] != NoRights   )
14859                 *p++ = boards[move][CASTLING][0] + AAA + 'A' - 'a';
14860            if(boards[move][CASTLING][2] != NoRights &&
14861               boards[move][CASTLING][1] != NoRights   )
14862                 *p++ = boards[move][CASTLING][1] + AAA + 'A' - 'a';
14863            if(boards[move][CASTLING][5] != NoRights &&
14864               boards[move][CASTLING][3] != NoRights   )
14865                 *p++ = boards[move][CASTLING][3] + AAA;
14866            if(boards[move][CASTLING][5] != NoRights &&
14867               boards[move][CASTLING][4] != NoRights   )
14868                 *p++ = boards[move][CASTLING][4] + AAA;
14869      } else {
14870
14871         /* [HGM] write true castling rights */
14872         if( nrCastlingRights == 6 ) {
14873             if(boards[move][CASTLING][0] == BOARD_RGHT-1 &&
14874                boards[move][CASTLING][2] != NoRights  ) *p++ = 'K';
14875             if(boards[move][CASTLING][1] == BOARD_LEFT &&
14876                boards[move][CASTLING][2] != NoRights  ) *p++ = 'Q';
14877             if(boards[move][CASTLING][3] == BOARD_RGHT-1 &&
14878                boards[move][CASTLING][5] != NoRights  ) *p++ = 'k';
14879             if(boards[move][CASTLING][4] == BOARD_LEFT &&
14880                boards[move][CASTLING][5] != NoRights  ) *p++ = 'q';
14881         }
14882      }
14883      if (q == p) *p++ = '-'; /* No castling rights */
14884      *p++ = ' ';
14885   }
14886
14887   if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
14888      gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier && gameInfo.variant != VariantMakruk ) {
14889     /* En passant target square */
14890     if (move > backwardMostMove) {
14891         fromX = moveList[move - 1][0] - AAA;
14892         fromY = moveList[move - 1][1] - ONE;
14893         toX = moveList[move - 1][2] - AAA;
14894         toY = moveList[move - 1][3] - ONE;
14895         if (fromY == (whiteToPlay ? BOARD_HEIGHT-2 : 1) &&
14896             toY == (whiteToPlay ? BOARD_HEIGHT-4 : 3) &&
14897             boards[move][toY][toX] == (whiteToPlay ? BlackPawn : WhitePawn) &&
14898             fromX == toX) {
14899             /* 2-square pawn move just happened */
14900             *p++ = toX + AAA;
14901             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
14902         } else {
14903             *p++ = '-';
14904         }
14905     } else if(move == backwardMostMove) {
14906         // [HGM] perhaps we should always do it like this, and forget the above?
14907         if((signed char)boards[move][EP_STATUS] >= 0) {
14908             *p++ = boards[move][EP_STATUS] + AAA;
14909             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
14910         } else {
14911             *p++ = '-';
14912         }
14913     } else {
14914         *p++ = '-';
14915     }
14916     *p++ = ' ';
14917   }
14918   }
14919
14920     /* [HGM] find reversible plies */
14921     {   int i = 0, j=move;
14922
14923         if (appData.debugMode) { int k;
14924             fprintf(debugFP, "write FEN 50-move: %d %d %d\n", initialRulePlies, forwardMostMove, backwardMostMove);
14925             for(k=backwardMostMove; k<=forwardMostMove; k++)
14926                 fprintf(debugFP, "e%d. p=%d\n", k, (signed char)boards[k][EP_STATUS]);
14927
14928         }
14929
14930         while(j > backwardMostMove && (signed char)boards[j][EP_STATUS] <= EP_NONE) j--,i++;
14931         if( j == backwardMostMove ) i += initialRulePlies;
14932         sprintf(p, "%d ", i);
14933         p += i>=100 ? 4 : i >= 10 ? 3 : 2;
14934     }
14935     /* Fullmove number */
14936     sprintf(p, "%d", (move / 2) + 1);
14937
14938     return StrSave(buf);
14939 }
14940
14941 Boolean
14942 ParseFEN(board, blackPlaysFirst, fen)
14943     Board board;
14944      int *blackPlaysFirst;
14945      char *fen;
14946 {
14947     int i, j;
14948     char *p, c;
14949     int emptycount;
14950     ChessSquare piece;
14951
14952     p = fen;
14953
14954     /* [HGM] by default clear Crazyhouse holdings, if present */
14955     if(gameInfo.holdingsWidth) {
14956        for(i=0; i<BOARD_HEIGHT; i++) {
14957            board[i][0]             = EmptySquare; /* black holdings */
14958            board[i][BOARD_WIDTH-1] = EmptySquare; /* white holdings */
14959            board[i][1]             = (ChessSquare) 0; /* black counts */
14960            board[i][BOARD_WIDTH-2] = (ChessSquare) 0; /* white counts */
14961        }
14962     }
14963
14964     /* Piece placement data */
14965     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
14966         j = 0;
14967         for (;;) {
14968             if (*p == '/' || *p == ' ' || (*p == '[' && i == 0) ) {
14969                 if (*p == '/') p++;
14970                 emptycount = gameInfo.boardWidth - j;
14971                 while (emptycount--)
14972                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
14973                 break;
14974 #if(BOARD_FILES >= 10)
14975             } else if(*p=='x' || *p=='X') { /* [HGM] X means 10 */
14976                 p++; emptycount=10;
14977                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
14978                 while (emptycount--)
14979                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
14980 #endif
14981             } else if (isdigit(*p)) {
14982                 emptycount = *p++ - '0';
14983                 while(isdigit(*p)) emptycount = 10*emptycount + *p++ - '0'; /* [HGM] allow > 9 */
14984                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
14985                 while (emptycount--)
14986                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
14987             } else if (*p == '+' || isalpha(*p)) {
14988                 if (j >= gameInfo.boardWidth) return FALSE;
14989                 if(*p=='+') {
14990                     piece = CharToPiece(*++p);
14991                     if(piece == EmptySquare) return FALSE; /* unknown piece */
14992                     piece = (ChessSquare) (PROMOTED piece ); p++;
14993                     if(PieceToChar(piece) != '+') return FALSE; /* unpromotable piece */
14994                 } else piece = CharToPiece(*p++);
14995
14996                 if(piece==EmptySquare) return FALSE; /* unknown piece */
14997                 if(*p == '~') { /* [HGM] make it a promoted piece for Crazyhouse */
14998                     piece = (ChessSquare) (PROMOTED piece);
14999                     if(PieceToChar(piece) != '~') return FALSE; /* cannot be a promoted piece */
15000                     p++;
15001                 }
15002                 board[i][(j++)+gameInfo.holdingsWidth] = piece;
15003             } else {
15004                 return FALSE;
15005             }
15006         }
15007     }
15008     while (*p == '/' || *p == ' ') p++;
15009
15010     /* [HGM] look for Crazyhouse holdings here */
15011     while(*p==' ') p++;
15012     if( gameInfo.holdingsWidth && p[-1] == '/' || *p == '[') {
15013         if(*p == '[') p++;
15014         if(*p == '-' ) p++; /* empty holdings */ else {
15015             if( !gameInfo.holdingsWidth ) return FALSE; /* no room to put holdings! */
15016             /* if we would allow FEN reading to set board size, we would   */
15017             /* have to add holdings and shift the board read so far here   */
15018             while( (piece = CharToPiece(*p) ) != EmptySquare ) {
15019                 p++;
15020                 if((int) piece >= (int) BlackPawn ) {
15021                     i = (int)piece - (int)BlackPawn;
15022                     i = PieceToNumber((ChessSquare)i);
15023                     if( i >= gameInfo.holdingsSize ) return FALSE;
15024                     board[BOARD_HEIGHT-1-i][0] = piece; /* black holdings */
15025                     board[BOARD_HEIGHT-1-i][1]++;       /* black counts   */
15026                 } else {
15027                     i = (int)piece - (int)WhitePawn;
15028                     i = PieceToNumber((ChessSquare)i);
15029                     if( i >= gameInfo.holdingsSize ) return FALSE;
15030                     board[i][BOARD_WIDTH-1] = piece;    /* white holdings */
15031                     board[i][BOARD_WIDTH-2]++;          /* black holdings */
15032                 }
15033             }
15034         }
15035         if(*p == ']') p++;
15036     }
15037
15038     while(*p == ' ') p++;
15039
15040     /* Active color */
15041     c = *p++;
15042     if(appData.colorNickNames) {
15043       if( c == appData.colorNickNames[0] ) c = 'w'; else
15044       if( c == appData.colorNickNames[1] ) c = 'b';
15045     }
15046     switch (c) {
15047       case 'w':
15048         *blackPlaysFirst = FALSE;
15049         break;
15050       case 'b':
15051         *blackPlaysFirst = TRUE;
15052         break;
15053       default:
15054         return FALSE;
15055     }
15056
15057     /* [HGM] We NO LONGER ignore the rest of the FEN notation */
15058     /* return the extra info in global variiables             */
15059
15060     /* set defaults in case FEN is incomplete */
15061     board[EP_STATUS] = EP_UNKNOWN;
15062     for(i=0; i<nrCastlingRights; i++ ) {
15063         board[CASTLING][i] =
15064             gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom ? NoRights : initialRights[i];
15065     }   /* assume possible unless obviously impossible */
15066     if(initialRights[0]!=NoRights && board[castlingRank[0]][initialRights[0]] != WhiteRook) board[CASTLING][0] = NoRights;
15067     if(initialRights[1]!=NoRights && board[castlingRank[1]][initialRights[1]] != WhiteRook) board[CASTLING][1] = NoRights;
15068     if(initialRights[2]!=NoRights && board[castlingRank[2]][initialRights[2]] != WhiteUnicorn
15069                                   && board[castlingRank[2]][initialRights[2]] != WhiteKing) board[CASTLING][2] = NoRights;
15070     if(initialRights[3]!=NoRights && board[castlingRank[3]][initialRights[3]] != BlackRook) board[CASTLING][3] = NoRights;
15071     if(initialRights[4]!=NoRights && board[castlingRank[4]][initialRights[4]] != BlackRook) board[CASTLING][4] = NoRights;
15072     if(initialRights[5]!=NoRights && board[castlingRank[5]][initialRights[5]] != BlackUnicorn
15073                                   && board[castlingRank[5]][initialRights[5]] != BlackKing) board[CASTLING][5] = NoRights;
15074     FENrulePlies = 0;
15075
15076     while(*p==' ') p++;
15077     if(nrCastlingRights) {
15078       if(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-') {
15079           /* castling indicator present, so default becomes no castlings */
15080           for(i=0; i<nrCastlingRights; i++ ) {
15081                  board[CASTLING][i] = NoRights;
15082           }
15083       }
15084       while(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-' ||
15085              (gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) &&
15086              ( *p >= 'a' && *p < 'a' + gameInfo.boardWidth) ||
15087              ( *p >= 'A' && *p < 'A' + gameInfo.boardWidth)   ) {
15088         char c = *p++; int whiteKingFile=NoRights, blackKingFile=NoRights;
15089
15090         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
15091             if(board[BOARD_HEIGHT-1][i] == BlackKing) blackKingFile = i;
15092             if(board[0             ][i] == WhiteKing) whiteKingFile = i;
15093         }
15094         if(gameInfo.variant == VariantTwoKings || gameInfo.variant == VariantKnightmate)
15095             whiteKingFile = blackKingFile = BOARD_WIDTH >> 1; // for these variant scanning fails
15096         if(whiteKingFile == NoRights || board[0][whiteKingFile] != WhiteUnicorn
15097                                      && board[0][whiteKingFile] != WhiteKing) whiteKingFile = NoRights;
15098         if(blackKingFile == NoRights || board[BOARD_HEIGHT-1][blackKingFile] != BlackUnicorn
15099                                      && board[BOARD_HEIGHT-1][blackKingFile] != BlackKing) blackKingFile = NoRights;
15100         switch(c) {
15101           case'K':
15102               for(i=BOARD_RGHT-1; board[0][i]!=WhiteRook && i>whiteKingFile; i--);
15103               board[CASTLING][0] = i != whiteKingFile ? i : NoRights;
15104               board[CASTLING][2] = whiteKingFile;
15105               break;
15106           case'Q':
15107               for(i=BOARD_LEFT;  i<BOARD_RGHT && board[0][i]!=WhiteRook && i<whiteKingFile; i++);
15108               board[CASTLING][1] = i != whiteKingFile ? i : NoRights;
15109               board[CASTLING][2] = whiteKingFile;
15110               break;
15111           case'k':
15112               for(i=BOARD_RGHT-1; board[BOARD_HEIGHT-1][i]!=BlackRook && i>blackKingFile; i--);
15113               board[CASTLING][3] = i != blackKingFile ? i : NoRights;
15114               board[CASTLING][5] = blackKingFile;
15115               break;
15116           case'q':
15117               for(i=BOARD_LEFT; i<BOARD_RGHT && board[BOARD_HEIGHT-1][i]!=BlackRook && i<blackKingFile; i++);
15118               board[CASTLING][4] = i != blackKingFile ? i : NoRights;
15119               board[CASTLING][5] = blackKingFile;
15120           case '-':
15121               break;
15122           default: /* FRC castlings */
15123               if(c >= 'a') { /* black rights */
15124                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
15125                     if(board[BOARD_HEIGHT-1][i] == BlackKing) break;
15126                   if(i == BOARD_RGHT) break;
15127                   board[CASTLING][5] = i;
15128                   c -= AAA;
15129                   if(board[BOARD_HEIGHT-1][c] <  BlackPawn ||
15130                      board[BOARD_HEIGHT-1][c] >= BlackKing   ) break;
15131                   if(c > i)
15132                       board[CASTLING][3] = c;
15133                   else
15134                       board[CASTLING][4] = c;
15135               } else { /* white rights */
15136                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
15137                     if(board[0][i] == WhiteKing) break;
15138                   if(i == BOARD_RGHT) break;
15139                   board[CASTLING][2] = i;
15140                   c -= AAA - 'a' + 'A';
15141                   if(board[0][c] >= WhiteKing) break;
15142                   if(c > i)
15143                       board[CASTLING][0] = c;
15144                   else
15145                       board[CASTLING][1] = c;
15146               }
15147         }
15148       }
15149       for(i=0; i<nrCastlingRights; i++)
15150         if(board[CASTLING][i] != NoRights) initialRights[i] = board[CASTLING][i];
15151     if (appData.debugMode) {
15152         fprintf(debugFP, "FEN castling rights:");
15153         for(i=0; i<nrCastlingRights; i++)
15154         fprintf(debugFP, " %d", board[CASTLING][i]);
15155         fprintf(debugFP, "\n");
15156     }
15157
15158       while(*p==' ') p++;
15159     }
15160
15161     /* read e.p. field in games that know e.p. capture */
15162     if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
15163        gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier && gameInfo.variant != VariantMakruk ) {
15164       if(*p=='-') {
15165         p++; board[EP_STATUS] = EP_NONE;
15166       } else {
15167          char c = *p++ - AAA;
15168
15169          if(c < BOARD_LEFT || c >= BOARD_RGHT) return TRUE;
15170          if(*p >= '0' && *p <='9') p++;
15171          board[EP_STATUS] = c;
15172       }
15173     }
15174
15175
15176     if(sscanf(p, "%d", &i) == 1) {
15177         FENrulePlies = i; /* 50-move ply counter */
15178         /* (The move number is still ignored)    */
15179     }
15180
15181     return TRUE;
15182 }
15183
15184 void
15185 EditPositionPasteFEN(char *fen)
15186 {
15187   if (fen != NULL) {
15188     Board initial_position;
15189
15190     if (!ParseFEN(initial_position, &blackPlaysFirst, fen)) {
15191       DisplayError(_("Bad FEN position in clipboard"), 0);
15192       return ;
15193     } else {
15194       int savedBlackPlaysFirst = blackPlaysFirst;
15195       EditPositionEvent();
15196       blackPlaysFirst = savedBlackPlaysFirst;
15197       CopyBoard(boards[0], initial_position);
15198       initialRulePlies = FENrulePlies; /* [HGM] copy FEN attributes as well */
15199       EditPositionDone(FALSE); // [HGM] fake: do not fake rights if we had FEN
15200       DisplayBothClocks();
15201       DrawPosition(FALSE, boards[currentMove]);
15202     }
15203   }
15204 }
15205
15206 static char cseq[12] = "\\   ";
15207
15208 Boolean set_cont_sequence(char *new_seq)
15209 {
15210     int len;
15211     Boolean ret;
15212
15213     // handle bad attempts to set the sequence
15214         if (!new_seq)
15215                 return 0; // acceptable error - no debug
15216
15217     len = strlen(new_seq);
15218     ret = (len > 0) && (len < sizeof(cseq));
15219     if (ret)
15220       safeStrCpy(cseq, new_seq, sizeof(cseq)/sizeof(cseq[0]));
15221     else if (appData.debugMode)
15222       fprintf(debugFP, "Invalid continuation sequence \"%s\"  (maximum length is: %u)\n", new_seq, (unsigned) sizeof(cseq)-1);
15223     return ret;
15224 }
15225
15226 /*
15227     reformat a source message so words don't cross the width boundary.  internal
15228     newlines are not removed.  returns the wrapped size (no null character unless
15229     included in source message).  If dest is NULL, only calculate the size required
15230     for the dest buffer.  lp argument indicats line position upon entry, and it's
15231     passed back upon exit.
15232 */
15233 int wrap(char *dest, char *src, int count, int width, int *lp)
15234 {
15235     int len, i, ansi, cseq_len, line, old_line, old_i, old_len, clen;
15236
15237     cseq_len = strlen(cseq);
15238     old_line = line = *lp;
15239     ansi = len = clen = 0;
15240
15241     for (i=0; i < count; i++)
15242     {
15243         if (src[i] == '\033')
15244             ansi = 1;
15245
15246         // if we hit the width, back up
15247         if (!ansi && (line >= width) && src[i] != '\n' && src[i] != ' ')
15248         {
15249             // store i & len in case the word is too long
15250             old_i = i, old_len = len;
15251
15252             // find the end of the last word
15253             while (i && src[i] != ' ' && src[i] != '\n')
15254             {
15255                 i--;
15256                 len--;
15257             }
15258
15259             // word too long?  restore i & len before splitting it
15260             if ((old_i-i+clen) >= width)
15261             {
15262                 i = old_i;
15263                 len = old_len;
15264             }
15265
15266             // extra space?
15267             if (i && src[i-1] == ' ')
15268                 len--;
15269
15270             if (src[i] != ' ' && src[i] != '\n')
15271             {
15272                 i--;
15273                 if (len)
15274                     len--;
15275             }
15276
15277             // now append the newline and continuation sequence
15278             if (dest)
15279                 dest[len] = '\n';
15280             len++;
15281             if (dest)
15282                 strncpy(dest+len, cseq, cseq_len);
15283             len += cseq_len;
15284             line = cseq_len;
15285             clen = cseq_len;
15286             continue;
15287         }
15288
15289         if (dest)
15290             dest[len] = src[i];
15291         len++;
15292         if (!ansi)
15293             line++;
15294         if (src[i] == '\n')
15295             line = 0;
15296         if (src[i] == 'm')
15297             ansi = 0;
15298     }
15299     if (dest && appData.debugMode)
15300     {
15301         fprintf(debugFP, "wrap(count:%d,width:%d,line:%d,len:%d,*lp:%d,src: ",
15302             count, width, line, len, *lp);
15303         show_bytes(debugFP, src, count);
15304         fprintf(debugFP, "\ndest: ");
15305         show_bytes(debugFP, dest, len);
15306         fprintf(debugFP, "\n");
15307     }
15308     *lp = dest ? line : old_line;
15309
15310     return len;
15311 }
15312
15313 // [HGM] vari: routines for shelving variations
15314
15315 void
15316 PushTail(int firstMove, int lastMove)
15317 {
15318         int i, j, nrMoves = lastMove - firstMove;
15319
15320         if(appData.icsActive) { // only in local mode
15321                 forwardMostMove = currentMove; // mimic old ICS behavior
15322                 return;
15323         }
15324         if(storedGames >= MAX_VARIATIONS-1) return;
15325
15326         // push current tail of game on stack
15327         savedResult[storedGames] = gameInfo.result;
15328         savedDetails[storedGames] = gameInfo.resultDetails;
15329         gameInfo.resultDetails = NULL;
15330         savedFirst[storedGames] = firstMove;
15331         savedLast [storedGames] = lastMove;
15332         savedFramePtr[storedGames] = framePtr;
15333         framePtr -= nrMoves; // reserve space for the boards
15334         for(i=nrMoves; i>=1; i--) { // copy boards to stack, working downwards, in case of overlap
15335             CopyBoard(boards[framePtr+i], boards[firstMove+i]);
15336             for(j=0; j<MOVE_LEN; j++)
15337                 moveList[framePtr+i][j] = moveList[firstMove+i-1][j];
15338             for(j=0; j<2*MOVE_LEN; j++)
15339                 parseList[framePtr+i][j] = parseList[firstMove+i-1][j];
15340             timeRemaining[0][framePtr+i] = timeRemaining[0][firstMove+i];
15341             timeRemaining[1][framePtr+i] = timeRemaining[1][firstMove+i];
15342             pvInfoList[framePtr+i] = pvInfoList[firstMove+i-1];
15343             pvInfoList[firstMove+i-1].depth = 0;
15344             commentList[framePtr+i] = commentList[firstMove+i];
15345             commentList[firstMove+i] = NULL;
15346         }
15347
15348         storedGames++;
15349         forwardMostMove = firstMove; // truncate game so we can start variation
15350         if(storedGames == 1) GreyRevert(FALSE);
15351 }
15352
15353 Boolean
15354 PopTail(Boolean annotate)
15355 {
15356         int i, j, nrMoves;
15357         char buf[8000], moveBuf[20];
15358
15359         if(appData.icsActive) return FALSE; // only in local mode
15360         if(!storedGames) return FALSE; // sanity
15361         CommentPopDown(); // make sure no stale variation comments to the destroyed line can remain open
15362
15363         storedGames--;
15364         ToNrEvent(savedFirst[storedGames]); // sets currentMove
15365         nrMoves = savedLast[storedGames] - currentMove;
15366         if(annotate) {
15367                 int cnt = 10;
15368                 if(!WhiteOnMove(currentMove))
15369                   snprintf(buf, sizeof(buf)/sizeof(buf[0]),"(%d...", (currentMove+2)>>1);
15370                 else safeStrCpy(buf, "(", sizeof(buf)/sizeof(buf[0]));
15371                 for(i=currentMove; i<forwardMostMove; i++) {
15372                         if(WhiteOnMove(i))
15373                           snprintf(moveBuf, sizeof(moveBuf)/sizeof(moveBuf[0]), " %d. %s", (i+2)>>1, SavePart(parseList[i]));
15374                         else snprintf(moveBuf, sizeof(moveBuf)/sizeof(moveBuf[0])," %s", SavePart(parseList[i]));
15375                         strcat(buf, moveBuf);
15376                         if(commentList[i]) { strcat(buf, " "); strcat(buf, commentList[i]); }
15377                         if(!--cnt) { strcat(buf, "\n"); cnt = 10; }
15378                 }
15379                 strcat(buf, ")");
15380         }
15381         for(i=1; i<=nrMoves; i++) { // copy last variation back
15382             CopyBoard(boards[currentMove+i], boards[framePtr+i]);
15383             for(j=0; j<MOVE_LEN; j++)
15384                 moveList[currentMove+i-1][j] = moveList[framePtr+i][j];
15385             for(j=0; j<2*MOVE_LEN; j++)
15386                 parseList[currentMove+i-1][j] = parseList[framePtr+i][j];
15387             timeRemaining[0][currentMove+i] = timeRemaining[0][framePtr+i];
15388             timeRemaining[1][currentMove+i] = timeRemaining[1][framePtr+i];
15389             pvInfoList[currentMove+i-1] = pvInfoList[framePtr+i];
15390             if(commentList[currentMove+i]) free(commentList[currentMove+i]);
15391             commentList[currentMove+i] = commentList[framePtr+i];
15392             commentList[framePtr+i] = NULL;
15393         }
15394         if(annotate) AppendComment(currentMove+1, buf, FALSE);
15395         framePtr = savedFramePtr[storedGames];
15396         gameInfo.result = savedResult[storedGames];
15397         if(gameInfo.resultDetails != NULL) {
15398             free(gameInfo.resultDetails);
15399       }
15400         gameInfo.resultDetails = savedDetails[storedGames];
15401         forwardMostMove = currentMove + nrMoves;
15402         if(storedGames == 0) GreyRevert(TRUE);
15403         return TRUE;
15404 }
15405
15406 void
15407 CleanupTail()
15408 {       // remove all shelved variations
15409         int i;
15410         for(i=0; i<storedGames; i++) {
15411             if(savedDetails[i])
15412                 free(savedDetails[i]);
15413             savedDetails[i] = NULL;
15414         }
15415         for(i=framePtr; i<MAX_MOVES; i++) {
15416                 if(commentList[i]) free(commentList[i]);
15417                 commentList[i] = NULL;
15418         }
15419         framePtr = MAX_MOVES-1;
15420         storedGames = 0;
15421 }
15422
15423 void
15424 LoadVariation(int index, char *text)
15425 {       // [HGM] vari: shelve previous line and load new variation, parsed from text around text[index]
15426         char *p = text, *start = NULL, *end = NULL, wait = NULLCHAR;
15427         int level = 0, move;
15428
15429         if(gameMode != EditGame && gameMode != AnalyzeMode) return;
15430         // first find outermost bracketing variation
15431         while(*p) { // hope I got this right... Non-nesting {} and [] can screen each other and nesting ()
15432             if(!wait) { // while inside [] pr {}, ignore everyting except matching closing ]}
15433                 if(*p == '{') wait = '}'; else
15434                 if(*p == '[') wait = ']'; else
15435                 if(*p == '(' && level++ == 0 && p-text < index) start = p+1;
15436                 if(*p == ')' && level > 0 && --level == 0 && p-text > index && end == NULL) end = p-1;
15437             }
15438             if(*p == wait) wait = NULLCHAR; // closing ]} found
15439             p++;
15440         }
15441         if(!start || !end) return; // no variation found, or syntax error in PGN: ignore click
15442         if(appData.debugMode) fprintf(debugFP, "at move %d load variation '%s'\n", currentMove, start);
15443         end[1] = NULLCHAR; // clip off comment beyond variation
15444         ToNrEvent(currentMove-1);
15445         PushTail(currentMove, forwardMostMove); // shelve main variation. This truncates game
15446         // kludge: use ParsePV() to append variation to game
15447         move = currentMove;
15448         ParsePV(start, TRUE);
15449         forwardMostMove = endPV; endPV = -1; currentMove = move; // cleanup what ParsePV did
15450         ClearPremoveHighlights();
15451         CommentPopDown();
15452         ToNrEvent(currentMove+1);
15453 }
15454