backend.c

   1 /*
   2  * backend.c -- Common back end for X and Windows NT versions of
   3  *
   4  * Copyright 1991 by Digital Equipment Corporation, Maynard,
   5  * Massachusetts.
   6  *
   7  * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
   8  * 2007, 2008, 2009 Free Software Foundation, Inc.
   9  *
  10  * Enhancements Copyright 2005 Alessandro Scotti
  11  *
  12  * The following terms apply to Digital Equipment Corporation's copyright
  13  * interest in XBoard:
  14  * ------------------------------------------------------------------------
  15  * All Rights Reserved
  16  *
  17  * Permission to use, copy, modify, and distribute this software and its
  18  * documentation for any purpose and without fee is hereby granted,
  19  * provided that the above copyright notice appear in all copies and that
  20  * both that copyright notice and this permission notice appear in
  21  * supporting documentation, and that the name of Digital not be
  22  * used in advertising or publicity pertaining to distribution of the
  23  * software without specific, written prior permission.
  24  *
  25  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  26  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  27  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  28  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  29  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  30  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  31  * SOFTWARE.
  32  * ------------------------------------------------------------------------
  33  *
  34  * The following terms apply to the enhanced version of XBoard
  35  * distributed by the Free Software Foundation:
  36  * ------------------------------------------------------------------------
  37  *
  38  * GNU XBoard is free software: you can redistribute it and/or modify
  39  * it under the terms of the GNU General Public License as published by
  40  * the Free Software Foundation, either version 3 of the License, or (at
  41  * your option) any later version.
  42  *
  43  * GNU XBoard is distributed in the hope that it will be useful, but
  44  * WITHOUT ANY WARRANTY; without even the implied warranty of
  45  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  46  * General Public License for more details.
  47  *
  48  * You should have received a copy of the GNU General Public License
  49  * along with this program. If not, see http://www.gnu.org/licenses/.  *
  50  *
  51  *------------------------------------------------------------------------
  52  ** See the file ChangeLog for a revision history.  */
  53
  54 /* [AS] Also useful here for debugging */
  55 #ifdef WIN32
  56 #include <windows.h>
  57
  58 #define DoSleep( n ) if( (n) != 0 ) Sleep( (n) );
  59
  60 #else
  61
  62 #define DoSleep( n ) if( (n) >= 0) sleep(n)
  63
  64 #endif
  65
  66 #include "config.h"
  67
  68 #include <assert.h>
  69 #include <stdio.h>
  70 #include <ctype.h>
  71 #include <errno.h>
  72 #include <sys/types.h>
  73 #include <sys/stat.h>
  74 #include <math.h>
  75 #include <ctype.h>
  76
  77 #if STDC_HEADERS
  78 # include <stdlib.h>
  79 # include <string.h>
  80 # include <stdarg.h>
  81 #else /* not STDC_HEADERS */
  82 # if HAVE_STRING_H
  83 #  include <string.h>
  84 # else /* not HAVE_STRING_H */
  85 #  include <strings.h>
  86 # endif /* not HAVE_STRING_H */
  87 #endif /* not STDC_HEADERS */
  88
  89 #if HAVE_SYS_FCNTL_H
  90 # include <sys/fcntl.h>
  91 #else /* not HAVE_SYS_FCNTL_H */
  92 # if HAVE_FCNTL_H
  93 #  include <fcntl.h>
  94 # endif /* HAVE_FCNTL_H */
  95 #endif /* not HAVE_SYS_FCNTL_H */
  96
  97 #if TIME_WITH_SYS_TIME
  98 # include <sys/time.h>
  99 # include <time.h>
 100 #else
 101 # if HAVE_SYS_TIME_H
 102 #  include <sys/time.h>
 103 # else
 104 #  include <time.h>
 105 # endif
 106 #endif
 107
 108 #if defined(_amigados) && !defined(__GNUC__)
 109 struct timezone {
 110     int tz_minuteswest;
 111     int tz_dsttime;
 112 };
 113 extern int gettimeofday(struct timeval *, struct timezone *);
 114 #endif
 115
 116 #if HAVE_UNISTD_H
 117 # include <unistd.h>
 118 #endif
 119
 120 #include "common.h"
 121 #include "frontend.h"
 122 #include "backend.h"
 123 #include "parser.h"
 124 #include "moves.h"
 125 #if ZIPPY
 126 # include "zippy.h"
 127 #endif
 128 #include "backendz.h"
 129 #include "gettext.h"
 130
 131 #ifdef ENABLE_NLS
 132 # define _(s) gettext (s)
 133 # define N_(s) gettext_noop (s)
 134 #else
 135 # define _(s) (s)
 136 # define N_(s) s
 137 #endif
 138
 139
 140 /* A point in time */
 141 typedef struct {
 142     long sec;  /* Assuming this is >= 32 bits */
 143     int ms;    /* Assuming this is >= 16 bits */
 144 } TimeMark;
 145
 146 int establish P((void));
 147 void read_from_player P((InputSourceRef isr, VOIDSTAR closure,
 148                          char *buf, int count, int error));
 149 void read_from_ics P((InputSourceRef isr, VOIDSTAR closure,
 150                       char *buf, int count, int error));
 151 void ics_printf P((char *format, ...));
 152 void SendToICS P((char *s));
 153 void SendToICSDelayed P((char *s, long msdelay));
 154 void SendMoveToICS P((ChessMove moveType, int fromX, int fromY,
 155                       int toX, int toY));
 156 void HandleMachineMove P((char *message, ChessProgramState *cps));
 157 int AutoPlayOneMove P((void));
 158 int LoadGameOneMove P((ChessMove readAhead));
 159 int LoadGameFromFile P((char *filename, int n, char *title, int useList));
 160 int LoadPositionFromFile P((char *filename, int n, char *title));
 161 int SavePositionToFile P((char *filename));
 162 void ApplyMove P((int fromX, int fromY, int toX, int toY, int promoChar,
 163                   Board board, char *castle, char *ep));
 164 void MakeMove P((int fromX, int fromY, int toX, int toY, int promoChar));
 165 void ShowMove P((int fromX, int fromY, int toX, int toY));
 166 int FinishMove P((ChessMove moveType, int fromX, int fromY, int toX, int toY,
 167                    /*char*/int promoChar));
 168 void BackwardInner P((int target));
 169 void ForwardInner P((int target));
 170 void GameEnds P((ChessMove result, char *resultDetails, int whosays));
 171 void EditPositionDone P((void));
 172 void PrintOpponents P((FILE *fp));
 173 void PrintPosition P((FILE *fp, int move));
 174 void StartChessProgram P((ChessProgramState *cps));
 175 void SendToProgram P((char *message, ChessProgramState *cps));
 176 void SendMoveToProgram P((int moveNum, ChessProgramState *cps));
 177 void ReceiveFromProgram P((InputSourceRef isr, VOIDSTAR closure,
 178                            char *buf, int count, int error));
 179 void SendTimeControl P((ChessProgramState *cps,
 180                         int mps, long tc, int inc, int sd, int st));
 181 char *TimeControlTagValue P((void));
 182 void Attention P((ChessProgramState *cps));
 183 void FeedMovesToProgram P((ChessProgramState *cps, int upto));
 184 void ResurrectChessProgram P((void));
 185 void DisplayComment P((int moveNumber, char *text));
 186 void DisplayMove P((int moveNumber));
 187
 188 void ParseGameHistory P((char *game));
 189 void ParseBoard12 P((char *string));
 190 void StartClocks P((void));
 191 void SwitchClocks P((void));
 192 void StopClocks P((void));
 193 void ResetClocks P((void));
 194 char *PGNDate P((void));
 195 void SetGameInfo P((void));
 196 Boolean ParseFEN P((Board board, int *blackPlaysFirst, char *fen));
 197 int RegisterMove P((void));
 198 void MakeRegisteredMove P((void));
 199 void TruncateGame P((void));
 200 int looking_at P((char *, int *, char *));
 201 void CopyPlayerNameIntoFileName P((char **, char *));
 202 char *SavePart P((char *));
 203 int SaveGameOldStyle P((FILE *));
 204 int SaveGamePGN P((FILE *));
 205 void GetTimeMark P((TimeMark *));
 206 long SubtractTimeMarks P((TimeMark *, TimeMark *));
 207 int CheckFlags P((void));
 208 long NextTickLength P((long));
 209 void CheckTimeControl P((void));
 210 void show_bytes P((FILE *, char *, int));
 211 int string_to_rating P((char *str));
 212 void ParseFeatures P((char* args, ChessProgramState *cps));
 213 void InitBackEnd3 P((void));
 214 void FeatureDone P((ChessProgramState* cps, int val));
 215 void InitChessProgram P((ChessProgramState *cps, int setup));
 216 void OutputKibitz(int window, char *text);
 217 int PerpetualChase(int first, int last);
 218 int EngineOutputIsUp();
 219 void InitDrawingSizes(int x, int y);
 220
 221 #ifdef WIN32
 222        extern void ConsoleCreate();
 223 #endif
 224
 225 ChessProgramState *WhitePlayer();
 226 void InsertIntoMemo P((int which, char *text)); // [HGM] kibitz: in engineo.c
 227 int VerifyDisplayMode P(());
 228
 229 char *GetInfoFromComment( int, char * ); // [HGM] PV time: returns stripped comment
 230 void InitEngineUCI( const char * iniDir, ChessProgramState * cps ); // [HGM] moved here from winboard.c
 231 char *ProbeBook P((int moveNr, char *book)); // [HGM] book: returns a book move
 232 char *SendMoveToBookUser P((int nr, ChessProgramState *cps, int initial)); // [HGM] book
 233 void ics_update_width P((int new_width));
 234 extern char installDir[MSG_SIZ];
 235
 236 extern int tinyLayout, smallLayout;
 237 ChessProgramStats programStats;
 238 static int exiting = 0; /* [HGM] moved to top */
 239 static int setboardSpoiledMachineBlack = 0 /*, errorExitFlag = 0*/;
 240 int startedFromPositionFile = FALSE; Board filePosition;       /* [HGM] loadPos */
 241 char endingGame = 0;    /* [HGM] crash: flag to prevent recursion of GameEnds() */
 242 int whiteNPS, blackNPS; /* [HGM] nps: for easily making clocks aware of NPS     */
 243 VariantClass currentlyInitializedVariant; /* [HGM] variantswitch */
 244 int lastIndex = 0;      /* [HGM] autoinc: last game/position used in match mode */
 245 int opponentKibitzes;
 246 int lastSavedGame; /* [HGM] save: ID of game */
 247 char chatPartner[MAX_CHAT][MSG_SIZ]; /* [HGM] chat: list of chatting partners */
 248 extern int chatCount;
 249 int chattingPartner;
 250
 251 /* States for ics_getting_history */
 252 #define H_FALSE 0
 253 #define H_REQUESTED 1
 254 #define H_GOT_REQ_HEADER 2
 255 #define H_GOT_UNREQ_HEADER 3
 256 #define H_GETTING_MOVES 4
 257 #define H_GOT_UNWANTED_HEADER 5
 258
 259 /* whosays values for GameEnds */
 260 #define GE_ICS 0
 261 #define GE_ENGINE 1
 262 #define GE_PLAYER 2
 263 #define GE_FILE 3
 264 #define GE_XBOARD 4
 265 #define GE_ENGINE1 5
 266 #define GE_ENGINE2 6
 267
 268 /* Maximum number of games in a cmail message */
 269 #define CMAIL_MAX_GAMES 20
 270
 271 /* Different types of move when calling RegisterMove */
 272 #define CMAIL_MOVE   0
 273 #define CMAIL_RESIGN 1
 274 #define CMAIL_DRAW   2
 275 #define CMAIL_ACCEPT 3
 276
 277 /* Different types of result to remember for each game */
 278 #define CMAIL_NOT_RESULT 0
 279 #define CMAIL_OLD_RESULT 1
 280 #define CMAIL_NEW_RESULT 2
 281
 282 /* Telnet protocol constants */
 283 #define TN_WILL 0373
 284 #define TN_WONT 0374
 285 #define TN_DO   0375
 286 #define TN_DONT 0376
 287 #define TN_IAC  0377
 288 #define TN_ECHO 0001
 289 #define TN_SGA  0003
 290 #define TN_PORT 23
 291
 292 /* [AS] */
 293 static char * safeStrCpy( char * dst, const char * src, size_t count )
 294 {
 295     assert( dst != NULL );
 296     assert( src != NULL );
 297     assert( count > 0 );
 298
 299     strncpy( dst, src, count );
 300     dst[ count-1 ] = '\0';
 301     return dst;
 302 }
 303
 304 /* Some compiler can't cast u64 to double
 305  * This function do the job for us:
 306
 307  * We use the highest bit for cast, this only
 308  * works if the highest bit is not
 309  * in use (This should not happen)
 310  *
 311  * We used this for all compiler
 312  */
 313 double
 314 u64ToDouble(u64 value)
 315 {
 316   double r;
 317   u64 tmp = value & u64Const(0x7fffffffffffffff);
 318   r = (double)(s64)tmp;
 319   if (value & u64Const(0x8000000000000000))
 320        r +=  9.2233720368547758080e18; /* 2^63 */
 321  return r;
 322 }
 323
 324 /* Fake up flags for now, as we aren't keeping track of castling
 325    availability yet. [HGM] Change of logic: the flag now only
 326    indicates the type of castlings allowed by the rule of the game.
 327    The actual rights themselves are maintained in the array
 328    castlingRights, as part of the game history, and are not probed
 329    by this function.
 330  */
 331 int
 332 PosFlags(index)
 333 {
 334   int flags = F_ALL_CASTLE_OK;
 335   if ((index % 2) == 0) flags |= F_WHITE_ON_MOVE;
 336   switch (gameInfo.variant) {
 337   case VariantSuicide:
 338     flags &= ~F_ALL_CASTLE_OK;
 339   case VariantGiveaway:         // [HGM] moved this case label one down: seems Giveaway does have castling on ICC!
 340     flags |= F_IGNORE_CHECK;
 341   case VariantLosers:
 342     flags |= F_MANDATORY_CAPTURE; //[HGM] losers: sets flag so TestLegality rejects non-capts if capts exist
 343     break;
 344   case VariantAtomic:
 345     flags |= F_IGNORE_CHECK | F_ATOMIC_CAPTURE;
 346     break;
 347   case VariantKriegspiel:
 348     flags |= F_KRIEGSPIEL_CAPTURE;
 349     break;
 350   case VariantCapaRandom:
 351   case VariantFischeRandom:
 352     flags |= F_FRC_TYPE_CASTLING; /* [HGM] enable this through flag */
 353   case VariantNoCastle:
 354   case VariantShatranj:
 355   case VariantCourier:
 356     flags &= ~F_ALL_CASTLE_OK;
 357     break;
 358   default:
 359     break;
 360   }
 361   return flags;
 362 }
 363
 364 FILE *gameFileFP, *debugFP;
 365
 366 /*
 367     [AS] Note: sometimes, the sscanf() function is used to parse the input
 368     into a fixed-size buffer. Because of this, we must be prepared to
 369     receive strings as long as the size of the input buffer, which is currently
 370     set to 4K for Windows and 8K for the rest.
 371     So, we must either allocate sufficiently large buffers here, or
 372     reduce the size of the input buffer in the input reading part.
 373 */
 374
 375 char cmailMove[CMAIL_MAX_GAMES][MOVE_LEN], cmailMsg[MSG_SIZ];
 376 char bookOutput[MSG_SIZ*10], thinkOutput[MSG_SIZ*10], lastHint[MSG_SIZ];
 377 char thinkOutput1[MSG_SIZ*10];
 378
 379 ChessProgramState first, second;
 380
 381 /* premove variables */
 382 int premoveToX = 0;
 383 int premoveToY = 0;
 384 int premoveFromX = 0;
 385 int premoveFromY = 0;
 386 int premovePromoChar = 0;
 387 int gotPremove = 0;
 388 Boolean alarmSounded;
 389 /* end premove variables */
 390
 391 char *ics_prefix = "$";
 392 int ics_type = ICS_GENERIC;
 393
 394 int currentMove = 0, forwardMostMove = 0, backwardMostMove = 0;
 395 int pauseExamForwardMostMove = 0;
 396 int nCmailGames = 0, nCmailResults = 0, nCmailMovesRegistered = 0;
 397 int cmailMoveRegistered[CMAIL_MAX_GAMES], cmailResult[CMAIL_MAX_GAMES];
 398 int cmailMsgLoaded = FALSE, cmailMailedMove = FALSE;
 399 int cmailOldMove = -1, firstMove = TRUE, flipView = FALSE;
 400 int blackPlaysFirst = FALSE, startedFromSetupPosition = FALSE;
 401 int searchTime = 0, pausing = FALSE, pauseExamInvalid = FALSE;
 402 int whiteFlag = FALSE, blackFlag = FALSE;
 403 int userOfferedDraw = FALSE;
 404 int ics_user_moved = 0, ics_gamenum = -1, ics_getting_history = H_FALSE;
 405 int matchMode = FALSE, hintRequested = FALSE, bookRequested = FALSE;
 406 int cmailMoveType[CMAIL_MAX_GAMES];
 407 long ics_clock_paused = 0;
 408 ProcRef icsPR = NoProc, cmailPR = NoProc;
 409 InputSourceRef telnetISR = NULL, fromUserISR = NULL, cmailISR = NULL;
 410 GameMode gameMode = BeginningOfGame;
 411 char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2];
 412 char *commentList[MAX_MOVES], *cmailCommentList[CMAIL_MAX_GAMES];
 413 ChessProgramStats_Move pvInfoList[MAX_MOVES]; /* [AS] Info about engine thinking */
 414 int hiddenThinkOutputState = 0; /* [AS] */
 415 int adjudicateLossThreshold = 0; /* [AS] Automatic adjudication */
 416 int adjudicateLossPlies = 6;
 417 char white_holding[64], black_holding[64];
 418 TimeMark lastNodeCountTime;
 419 long lastNodeCount=0;
 420 int have_sent_ICS_logon = 0;
 421 int movesPerSession;
 422 long whiteTimeRemaining, blackTimeRemaining, timeControl, timeIncrement;
 423 long timeControl_2; /* [AS] Allow separate time controls */
 424 char *fullTimeControlString = NULL; /* [HGM] secondary TC: merge of MPS, TC and inc */
 425 long timeRemaining[2][MAX_MOVES];
 426 int matchGame = 0;
 427 TimeMark programStartTime;
 428 char ics_handle[MSG_SIZ];
 429 int have_set_title = 0;
 430
 431 /* animateTraining preserves the state of appData.animate
 432  * when Training mode is activated. This allows the
 433  * response to be animated when appData.animate == TRUE and
 434  * appData.animateDragging == TRUE.
 435  */
 436 Boolean animateTraining;
 437
 438 GameInfo gameInfo;
 439
 440 AppData appData;
 441
 442 Board boards[MAX_MOVES];
 443 /* [HGM] Following 7 needed for accurate legality tests: */
 444 signed char  epStatus[MAX_MOVES];
 445 signed char  castlingRights[MAX_MOVES][BOARD_SIZE]; // stores files for pieces with castling rights or -1
 446 signed char  castlingRank[BOARD_SIZE]; // and corresponding ranks
 447 signed char  initialRights[BOARD_SIZE], FENcastlingRights[BOARD_SIZE], fileRights[BOARD_SIZE];
 448 int   nrCastlingRights; // For TwoKings, or to implement castling-unknown status
 449 int   initialRulePlies, FENrulePlies;
 450 char  FENepStatus;
 451 FILE  *serverMoves = NULL; // next two for broadcasting (/serverMoves option)
 452 int loadFlag = 0;
 453 int shuffleOpenings;
 454 int mute; // mute all sounds
 455
 456 ChessSquare  FIDEArray[2][BOARD_SIZE] = {
 457     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 458         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 459     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 460         BlackKing, BlackBishop, BlackKnight, BlackRook }
 461 };
 462
 463 ChessSquare twoKingsArray[2][BOARD_SIZE] = {
 464     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 465         WhiteKing, WhiteKing, WhiteKnight, WhiteRook },
 466     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 467         BlackKing, BlackKing, BlackKnight, BlackRook }
 468 };
 469
 470 ChessSquare  KnightmateArray[2][BOARD_SIZE] = {
 471     { WhiteRook, WhiteMan, WhiteBishop, WhiteQueen,
 472         WhiteUnicorn, WhiteBishop, WhiteMan, WhiteRook },
 473     { BlackRook, BlackMan, BlackBishop, BlackQueen,
 474         BlackUnicorn, BlackBishop, BlackMan, BlackRook }
 475 };
 476
 477 ChessSquare fairyArray[2][BOARD_SIZE] = { /* [HGM] Queen side differs from King side */
 478     { WhiteCannon, WhiteNightrider, WhiteAlfil, WhiteQueen,
 479         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 480     { BlackCannon, BlackNightrider, BlackAlfil, BlackQueen,
 481         BlackKing, BlackBishop, BlackKnight, BlackRook }
 482 };
 483
 484 ChessSquare ShatranjArray[2][BOARD_SIZE] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 485     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteKing,
 486         WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 487     { BlackRook, BlackKnight, BlackAlfil, BlackKing,
 488         BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 489 };
 490
 491
 492 #if (BOARD_SIZE>=10)
 493 ChessSquare ShogiArray[2][BOARD_SIZE] = {
 494     { WhiteQueen, WhiteKnight, WhiteFerz, WhiteWazir,
 495         WhiteKing, WhiteWazir, WhiteFerz, WhiteKnight, WhiteQueen },
 496     { BlackQueen, BlackKnight, BlackFerz, BlackWazir,
 497         BlackKing, BlackWazir, BlackFerz, BlackKnight, BlackQueen }
 498 };
 499
 500 ChessSquare XiangqiArray[2][BOARD_SIZE] = {
 501     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteFerz,
 502         WhiteWazir, WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 503     { BlackRook, BlackKnight, BlackAlfil, BlackFerz,
 504         BlackWazir, BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 505 };
 506
 507 ChessSquare CapablancaArray[2][BOARD_SIZE] = {
 508     { WhiteRook, WhiteKnight, WhiteAngel, WhiteBishop, WhiteQueen,
 509         WhiteKing, WhiteBishop, WhiteMarshall, WhiteKnight, WhiteRook },
 510     { BlackRook, BlackKnight, BlackAngel, BlackBishop, BlackQueen,
 511         BlackKing, BlackBishop, BlackMarshall, BlackKnight, BlackRook }
 512 };
 513
 514 ChessSquare GreatArray[2][BOARD_SIZE] = {
 515     { WhiteDragon, WhiteKnight, WhiteAlfil, WhiteGrasshopper, WhiteKing,
 516         WhiteSilver, WhiteCardinal, WhiteAlfil, WhiteKnight, WhiteDragon },
 517     { BlackDragon, BlackKnight, BlackAlfil, BlackGrasshopper, BlackKing,
 518         BlackSilver, BlackCardinal, BlackAlfil, BlackKnight, BlackDragon },
 519 };
 520
 521 ChessSquare JanusArray[2][BOARD_SIZE] = {
 522     { WhiteRook, WhiteAngel, WhiteKnight, WhiteBishop, WhiteKing,
 523         WhiteQueen, WhiteBishop, WhiteKnight, WhiteAngel, WhiteRook },
 524     { BlackRook, BlackAngel, BlackKnight, BlackBishop, BlackKing,
 525         BlackQueen, BlackBishop, BlackKnight, BlackAngel, BlackRook }
 526 };
 527
 528 #ifdef GOTHIC
 529 ChessSquare GothicArray[2][BOARD_SIZE] = {
 530     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen, WhiteMarshall,
 531         WhiteKing, WhiteAngel, WhiteBishop, WhiteKnight, WhiteRook },
 532     { BlackRook, BlackKnight, BlackBishop, BlackQueen, BlackMarshall,
 533         BlackKing, BlackAngel, BlackBishop, BlackKnight, BlackRook }
 534 };
 535 #else // !GOTHIC
 536 #define GothicArray CapablancaArray
 537 #endif // !GOTHIC
 538
 539 #ifdef FALCON
 540 ChessSquare FalconArray[2][BOARD_SIZE] = {
 541     { WhiteRook, WhiteKnight, WhiteBishop, WhiteLance, WhiteQueen,
 542         WhiteKing, WhiteLance, WhiteBishop, WhiteKnight, WhiteRook },
 543     { BlackRook, BlackKnight, BlackBishop, BlackLance, BlackQueen,
 544         BlackKing, BlackLance, BlackBishop, BlackKnight, BlackRook }
 545 };
 546 #else // !FALCON
 547 #define FalconArray CapablancaArray
 548 #endif // !FALCON
 549
 550 #else // !(BOARD_SIZE>=10)
 551 #define XiangqiPosition FIDEArray
 552 #define CapablancaArray FIDEArray
 553 #define GothicArray FIDEArray
 554 #define GreatArray FIDEArray
 555 #endif // !(BOARD_SIZE>=10)
 556
 557 #if (BOARD_SIZE>=12)
 558 ChessSquare CourierArray[2][BOARD_SIZE] = {
 559     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteBishop, WhiteMan, WhiteKing,
 560         WhiteFerz, WhiteWazir, WhiteBishop, WhiteAlfil, WhiteKnight, WhiteRook },
 561     { BlackRook, BlackKnight, BlackAlfil, BlackBishop, BlackMan, BlackKing,
 562         BlackFerz, BlackWazir, BlackBishop, BlackAlfil, BlackKnight, BlackRook }
 563 };
 564 #else // !(BOARD_SIZE>=12)
 565 #define CourierArray CapablancaArray
 566 #endif // !(BOARD_SIZE>=12)
 567
 568
 569 Board initialPosition;
 570
 571
 572 /* Convert str to a rating. Checks for special cases of "----",
 573
 574    "++++", etc. Also strips ()'s */
 575 int
 576 string_to_rating(str)
 577   char *str;
 578 {
 579   while(*str && !isdigit(*str)) ++str;
 580   if (!*str)
 581     return 0;   /* One of the special "no rating" cases */
 582   else
 583     return atoi(str);
 584 }
 585
 586 void
 587 ClearProgramStats()
 588 {
 589     /* Init programStats */
 590     programStats.movelist[0] = 0;
 591     programStats.depth = 0;
 592     programStats.nr_moves = 0;
 593     programStats.moves_left = 0;
 594     programStats.nodes = 0;
 595     programStats.time = -1;        // [HGM] PGNtime: make invalid to recognize engine output
 596     programStats.score = 0;
 597     programStats.got_only_move = 0;
 598     programStats.got_fail = 0;
 599     programStats.line_is_book = 0;
 600 }
 601
 602 void
 603 InitBackEnd1()
 604 {
 605     int matched, min, sec;
 606
 607     ShowThinkingEvent(); // [HGM] thinking: make sure post/nopost state is set according to options
 608
 609     GetTimeMark(&programStartTime);
 610     srand(programStartTime.ms); // [HGM] book: makes sure random is unpredictabe to msec level
 611
 612     ClearProgramStats();
 613     programStats.ok_to_send = 1;
 614     programStats.seen_stat = 0;
 615
 616     /*
 617      * Initialize game list
 618      */
 619     ListNew(&gameList);
 620
 621
 622     /*
 623      * Internet chess server status
 624      */
 625     if (appData.icsActive) {
 626         appData.matchMode = FALSE;
 627         appData.matchGames = 0;
 628 #if ZIPPY
 629         appData.noChessProgram = !appData.zippyPlay;
 630 #else
 631         appData.zippyPlay = FALSE;
 632         appData.zippyTalk = FALSE;
 633         appData.noChessProgram = TRUE;
 634 #endif
 635         if (*appData.icsHelper != NULLCHAR) {
 636             appData.useTelnet = TRUE;
 637             appData.telnetProgram = appData.icsHelper;
 638         }
 639     } else {
 640         appData.zippyTalk = appData.zippyPlay = FALSE;
 641     }
 642
 643     /* [AS] Initialize pv info list [HGM] and game state */
 644     {
 645         int i, j;
 646
 647         for( i=0; i<MAX_MOVES; i++ ) {
 648             pvInfoList[i].depth = -1;
 649             epStatus[i]=EP_NONE;
 650             for( j=0; j<BOARD_SIZE; j++ ) castlingRights[i][j] = -1;
 651         }
 652     }
 653
 654     /*
 655      * Parse timeControl resource
 656      */
 657     if (!ParseTimeControl(appData.timeControl, appData.timeIncrement,
 658                           appData.movesPerSession)) {
 659         char buf[MSG_SIZ];
 660         snprintf(buf, sizeof(buf), _("bad timeControl option %s"), appData.timeControl);
 661         DisplayFatalError(buf, 0, 2);
 662     }
 663
 664     /*
 665      * Parse searchTime resource
 666      */
 667     if (*appData.searchTime != NULLCHAR) {
 668         matched = sscanf(appData.searchTime, "%d:%d", &min, &sec);
 669         if (matched == 1) {
 670             searchTime = min * 60;
 671         } else if (matched == 2) {
 672             searchTime = min * 60 + sec;
 673         } else {
 674             char buf[MSG_SIZ];
 675             snprintf(buf, sizeof(buf), _("bad searchTime option %s"), appData.searchTime);
 676             DisplayFatalError(buf, 0, 2);
 677         }
 678     }
 679
 680     /* [AS] Adjudication threshold */
 681     adjudicateLossThreshold = appData.adjudicateLossThreshold;
 682
 683     first.which = "first";
 684     second.which = "second";
 685     first.maybeThinking = second.maybeThinking = FALSE;
 686     first.pr = second.pr = NoProc;
 687     first.isr = second.isr = NULL;
 688     first.sendTime = second.sendTime = 2;
 689     first.sendDrawOffers = 1;
 690     if (appData.firstPlaysBlack) {
 691         first.twoMachinesColor = "black\n";
 692         second.twoMachinesColor = "white\n";
 693     } else {
 694         first.twoMachinesColor = "white\n";
 695         second.twoMachinesColor = "black\n";
 696     }
 697     first.program = appData.firstChessProgram;
 698     second.program = appData.secondChessProgram;
 699     first.host = appData.firstHost;
 700     second.host = appData.secondHost;
 701     first.dir = appData.firstDirectory;
 702     second.dir = appData.secondDirectory;
 703     first.other = &second;
 704     second.other = &first;
 705     first.initString = appData.initString;
 706     second.initString = appData.secondInitString;
 707     first.computerString = appData.firstComputerString;
 708     second.computerString = appData.secondComputerString;
 709     first.useSigint = second.useSigint = TRUE;
 710     first.useSigterm = second.useSigterm = TRUE;
 711     first.reuse = appData.reuseFirst;
 712     second.reuse = appData.reuseSecond;
 713     first.nps = appData.firstNPS;   // [HGM] nps: copy nodes per second
 714     second.nps = appData.secondNPS;
 715     first.useSetboard = second.useSetboard = FALSE;
 716     first.useSAN = second.useSAN = FALSE;
 717     first.usePing = second.usePing = FALSE;
 718     first.lastPing = second.lastPing = 0;
 719     first.lastPong = second.lastPong = 0;
 720     first.usePlayother = second.usePlayother = FALSE;
 721     first.useColors = second.useColors = TRUE;
 722     first.useUsermove = second.useUsermove = FALSE;
 723     first.sendICS = second.sendICS = FALSE;
 724     first.sendName = second.sendName = appData.icsActive;
 725     first.sdKludge = second.sdKludge = FALSE;
 726     first.stKludge = second.stKludge = FALSE;
 727     TidyProgramName(first.program, first.host, first.tidy);
 728     TidyProgramName(second.program, second.host, second.tidy);
 729     first.matchWins = second.matchWins = 0;
 730     strcpy(first.variants, appData.variant);
 731     strcpy(second.variants, appData.variant);
 732     first.analysisSupport = second.analysisSupport = 2; /* detect */
 733     first.analyzing = second.analyzing = FALSE;
 734     first.initDone = second.initDone = FALSE;
 735
 736     /* New features added by Tord: */
 737     first.useFEN960 = FALSE; second.useFEN960 = FALSE;
 738     first.useOOCastle = TRUE; second.useOOCastle = TRUE;
 739     /* End of new features added by Tord. */
 740     first.fenOverride  = appData.fenOverride1;
 741     second.fenOverride = appData.fenOverride2;
 742
 743     /* [HGM] time odds: set factor for each machine */
 744     first.timeOdds  = appData.firstTimeOdds;
 745     second.timeOdds = appData.secondTimeOdds;
 746     { int norm = 1;
 747         if(appData.timeOddsMode) {
 748             norm = first.timeOdds;
 749             if(norm > second.timeOdds) norm = second.timeOdds;
 750         }
 751         first.timeOdds /= norm;
 752         second.timeOdds /= norm;
 753     }
 754
 755     /* [HGM] secondary TC: how to handle sessions that do not fit in 'level'*/
 756     first.accumulateTC = appData.firstAccumulateTC;
 757     second.accumulateTC = appData.secondAccumulateTC;
 758     first.maxNrOfSessions = second.maxNrOfSessions = 1;
 759
 760     /* [HGM] debug */
 761     first.debug = second.debug = FALSE;
 762     first.supportsNPS = second.supportsNPS = UNKNOWN;
 763
 764     /* [HGM] options */
 765     first.optionSettings  = appData.firstOptions;
 766     second.optionSettings = appData.secondOptions;
 767
 768     first.scoreIsAbsolute = appData.firstScoreIsAbsolute; /* [AS] */
 769     second.scoreIsAbsolute = appData.secondScoreIsAbsolute; /* [AS] */
 770     first.isUCI = appData.firstIsUCI; /* [AS] */
 771     second.isUCI = appData.secondIsUCI; /* [AS] */
 772     first.hasOwnBookUCI = appData.firstHasOwnBookUCI; /* [AS] */
 773     second.hasOwnBookUCI = appData.secondHasOwnBookUCI; /* [AS] */
 774
 775     if (appData.firstProtocolVersion > PROTOVER ||
 776         appData.firstProtocolVersion < 1) {
 777       char buf[MSG_SIZ];
 778       sprintf(buf, _("protocol version %d not supported"),
 779               appData.firstProtocolVersion);
 780       DisplayFatalError(buf, 0, 2);
 781     } else {
 782       first.protocolVersion = appData.firstProtocolVersion;
 783     }
 784
 785     if (appData.secondProtocolVersion > PROTOVER ||
 786         appData.secondProtocolVersion < 1) {
 787       char buf[MSG_SIZ];
 788       sprintf(buf, _("protocol version %d not supported"),
 789               appData.secondProtocolVersion);
 790       DisplayFatalError(buf, 0, 2);
 791     } else {
 792       second.protocolVersion = appData.secondProtocolVersion;
 793     }
 794
 795     if (appData.icsActive) {
 796         appData.clockMode = TRUE;  /* changes dynamically in ICS mode */
 797     } else if (*appData.searchTime != NULLCHAR || appData.noChessProgram) {
 798         appData.clockMode = FALSE;
 799         first.sendTime = second.sendTime = 0;
 800     }
 801
 802 #if ZIPPY
 803     /* Override some settings from environment variables, for backward
 804        compatibility.  Unfortunately it's not feasible to have the env
 805        vars just set defaults, at least in xboard.  Ugh.
 806     */
 807     if (appData.icsActive && (appData.zippyPlay || appData.zippyTalk)) {
 808       ZippyInit();
 809     }
 810 #endif
 811
 812     if (appData.noChessProgram) {
 813         programVersion = (char*) malloc(5 + strlen(PACKAGE_STRING));
 814         sprintf(programVersion, "%s", PACKAGE_STRING);
 815     } else {
 816       /* [HGM] tidy: use tidy name, in stead of full pathname (which was probably a bug due to / vs \ ) */
 817       programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
 818       sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
 819     }
 820
 821     if (!appData.icsActive) {
 822       char buf[MSG_SIZ];
 823       /* Check for variants that are supported only in ICS mode,
 824          or not at all.  Some that are accepted here nevertheless
 825          have bugs; see comments below.
 826       */
 827       VariantClass variant = StringToVariant(appData.variant);
 828       switch (variant) {
 829       case VariantBughouse:     /* need four players and two boards */
 830       case VariantKriegspiel:   /* need to hide pieces and move details */
 831       /* case VariantFischeRandom: (Fabien: moved below) */
 832         sprintf(buf, _("Variant %s supported only in ICS mode"), appData.variant);
 833         DisplayFatalError(buf, 0, 2);
 834         return;
 835
 836       case VariantUnknown:
 837       case VariantLoadable:
 838       case Variant29:
 839       case Variant30:
 840       case Variant31:
 841       case Variant32:
 842       case Variant33:
 843       case Variant34:
 844       case Variant35:
 845       case Variant36:
 846       default:
 847         sprintf(buf, _("Unknown variant name %s"), appData.variant);
 848         DisplayFatalError(buf, 0, 2);
 849         return;
 850
 851       case VariantXiangqi:    /* [HGM] repetition rules not implemented */
 852       case VariantFairy:      /* [HGM] TestLegality definitely off! */
 853       case VariantGothic:     /* [HGM] should work */
 854       case VariantCapablanca: /* [HGM] should work */
 855       case VariantCourier:    /* [HGM] initial forced moves not implemented */
 856       case VariantShogi:      /* [HGM] drops not tested for legality */
 857       case VariantKnightmate: /* [HGM] should work */
 858       case VariantCylinder:   /* [HGM] untested */
 859       case VariantFalcon:     /* [HGM] untested */
 860       case VariantCrazyhouse: /* holdings not shown, ([HGM] fixed that!)
 861                                  offboard interposition not understood */
 862       case VariantNormal:     /* definitely works! */
 863       case VariantWildCastle: /* pieces not automatically shuffled */
 864       case VariantNoCastle:   /* pieces not automatically shuffled */
 865       case VariantFischeRandom: /* [HGM] works and shuffles pieces */
 866       case VariantLosers:     /* should work except for win condition,
 867                                  and doesn't know captures are mandatory */
 868       case VariantSuicide:    /* should work except for win condition,
 869                                  and doesn't know captures are mandatory */
 870       case VariantGiveaway:   /* should work except for win condition,
 871                                  and doesn't know captures are mandatory */
 872       case VariantTwoKings:   /* should work */
 873       case VariantAtomic:     /* should work except for win condition */
 874       case Variant3Check:     /* should work except for win condition */
 875       case VariantShatranj:   /* should work except for all win conditions */
 876       case VariantBerolina:   /* might work if TestLegality is off */
 877       case VariantCapaRandom: /* should work */
 878       case VariantJanus:      /* should work */
 879       case VariantSuper:      /* experimental */
 880       case VariantGreat:      /* experimental, requires legality testing to be off */
 881         break;
 882       }
 883     }
 884
 885     InitEngineUCI( installDir, &first );  // [HGM] moved here from winboard.c, to make available in xboard
 886     InitEngineUCI( installDir, &second );
 887 }
 888
 889 int NextIntegerFromString( char ** str, long * value )
 890 {
 891     int result = -1;
 892     char * s = *str;
 893
 894     while( *s == ' ' || *s == '\t' ) {
 895         s++;
 896     }
 897
 898     *value = 0;
 899
 900     if( *s >= '0' && *s <= '9' ) {
 901         while( *s >= '0' && *s <= '9' ) {
 902             *value = *value * 10 + (*s - '0');
 903             s++;
 904         }
 905
 906         result = 0;
 907     }
 908
 909     *str = s;
 910
 911     return result;
 912 }
 913
 914 int NextTimeControlFromString( char ** str, long * value )
 915 {
 916     long temp;
 917     int result = NextIntegerFromString( str, &temp );
 918
 919     if( result == 0 ) {
 920         *value = temp * 60; /* Minutes */
 921         if( **str == ':' ) {
 922             (*str)++;
 923             result = NextIntegerFromString( str, &temp );
 924             *value += temp; /* Seconds */
 925         }
 926     }
 927
 928     return result;
 929 }
 930
 931 int NextSessionFromString( char ** str, int *moves, long * tc, long *inc)
 932 {   /* [HGM] routine added to read '+moves/time' for secondary time control */
 933     int result = -1; long temp, temp2;
 934
 935     if(**str != '+') return -1; // old params remain in force!
 936     (*str)++;
 937     if( NextTimeControlFromString( str, &temp ) ) return -1;
 938
 939     if(**str != '/') {
 940         /* time only: incremental or sudden-death time control */
 941         if(**str == '+') { /* increment follows; read it */
 942             (*str)++;
 943             if(result = NextIntegerFromString( str, &temp2)) return -1;
 944             *inc = temp2 * 1000;
 945         } else *inc = 0;
 946         *moves = 0; *tc = temp * 1000;
 947         return 0;
 948     } else if(temp % 60 != 0) return -1;     /* moves was given as min:sec */
 949
 950     (*str)++; /* classical time control */
 951     result = NextTimeControlFromString( str, &temp2);
 952     if(result == 0) {
 953         *moves = temp/60;
 954         *tc    = temp2 * 1000;
 955         *inc   = 0;
 956     }
 957     return result;
 958 }
 959
 960 int GetTimeQuota(int movenr)
 961 {   /* [HGM] get time to add from the multi-session time-control string */
 962     int moves=1; /* kludge to force reading of first session */
 963     long time, increment;
 964     char *s = fullTimeControlString;
 965
 966     if(appData.debugMode) fprintf(debugFP, "TC string = '%s'\n", fullTimeControlString);
 967     do {
 968         if(moves) NextSessionFromString(&s, &moves, &time, &increment);
 969         if(appData.debugMode) fprintf(debugFP, "mps=%d tc=%d inc=%d\n", moves, (int) time, (int) increment);
 970         if(movenr == -1) return time;    /* last move before new session     */
 971         if(!moves) return increment;     /* current session is incremental   */
 972         if(movenr >= 0) movenr -= moves; /* we already finished this session */
 973     } while(movenr >= -1);               /* try again for next session       */
 974
 975     return 0; // no new time quota on this move
 976 }
 977
 978 int
 979 ParseTimeControl(tc, ti, mps)
 980      char *tc;
 981      int ti;
 982      int mps;
 983 {
 984   long tc1;
 985   long tc2;
 986   char buf[MSG_SIZ];
 987
 988   if(ti >= 0 && !strchr(tc, '+') && !strchr(tc, '/') ) mps = 0;
 989   if(ti > 0) {
 990     if(mps)
 991       sprintf(buf, "+%d/%s+%d", mps, tc, ti);
 992     else sprintf(buf, "+%s+%d", tc, ti);
 993   } else {
 994     if(mps)
 995              sprintf(buf, "+%d/%s", mps, tc);
 996     else sprintf(buf, "+%s", tc);
 997   }
 998   fullTimeControlString = StrSave(buf);
 999
1000   if( NextTimeControlFromString( &tc, &tc1 ) != 0 ) {
1001     return FALSE;
1002   }
1003
1004   if( *tc == '/' ) {
1005     /* Parse second time control */
1006     tc++;
1007
1008     if( NextTimeControlFromString( &tc, &tc2 ) != 0 ) {
1009       return FALSE;
1010     }
1011
1012     if( tc2 == 0 ) {
1013       return FALSE;
1014     }
1015
1016     timeControl_2 = tc2 * 1000;
1017   }
1018   else {
1019     timeControl_2 = 0;
1020   }
1021
1022   if( tc1 == 0 ) {
1023     return FALSE;
1024   }
1025
1026   timeControl = tc1 * 1000;
1027
1028   if (ti >= 0) {
1029     timeIncrement = ti * 1000;  /* convert to ms */
1030     movesPerSession = 0;
1031   } else {
1032     timeIncrement = 0;
1033     movesPerSession = mps;
1034   }
1035   return TRUE;
1036 }
1037
1038 void
1039 InitBackEnd2()
1040 {
1041     if (appData.debugMode) {
1042         fprintf(debugFP, "%s\n", programVersion);
1043     }
1044
1045     set_cont_sequence(appData.wrapContSeq);
1046     if (appData.matchGames > 0) {
1047         appData.matchMode = TRUE;
1048     } else if (appData.matchMode) {
1049         appData.matchGames = 1;
1050     }
1051     if(appData.matchMode && appData.sameColorGames > 0) /* [HGM] alternate: overrule matchGames */
1052         appData.matchGames = appData.sameColorGames;
1053     if(appData.rewindIndex > 1) { /* [HGM] autoinc: rewind implies auto-increment and overrules given index */
1054         if(appData.loadPositionIndex >= 0) appData.loadPositionIndex = -1;
1055         if(appData.loadGameIndex >= 0) appData.loadGameIndex = -1;
1056     }
1057     Reset(TRUE, FALSE);
1058     if (appData.noChessProgram || first.protocolVersion == 1) {
1059       InitBackEnd3();
1060     } else {
1061       /* kludge: allow timeout for initial "feature" commands */
1062       FreezeUI();
1063       DisplayMessage("", _("Starting chess program"));
1064       ScheduleDelayedEvent(InitBackEnd3, FEATURE_TIMEOUT);
1065     }
1066 }
1067
1068 void
1069 InitBackEnd3 P((void))
1070 {
1071     GameMode initialMode;
1072     char buf[MSG_SIZ];
1073     int err;
1074
1075     InitChessProgram(&first, startedFromSetupPosition);
1076
1077
1078     if (appData.icsActive) {
1079 #ifdef WIN32
1080         /* [DM] Make a console window if needed [HGM] merged ifs */
1081         ConsoleCreate();
1082 #endif
1083         err = establish();
1084         if (err != 0) {
1085             if (*appData.icsCommPort != NULLCHAR) {
1086                 sprintf(buf, _("Could not open comm port %s"),
1087                         appData.icsCommPort);
1088             } else {
1089                 snprintf(buf, sizeof(buf), _("Could not connect to host %s, port %s"),
1090                         appData.icsHost, appData.icsPort);
1091             }
1092             DisplayFatalError(buf, err, 1);
1093             return;
1094         }
1095         SetICSMode();
1096         telnetISR =
1097           AddInputSource(icsPR, FALSE, read_from_ics, &telnetISR);
1098         fromUserISR =
1099           AddInputSource(NoProc, FALSE, read_from_player, &fromUserISR);
1100     } else if (appData.noChessProgram) {
1101         SetNCPMode();
1102     } else {
1103         SetGNUMode();
1104     }
1105
1106     if (*appData.cmailGameName != NULLCHAR) {
1107         SetCmailMode();
1108         OpenLoopback(&cmailPR);
1109         cmailISR =
1110           AddInputSource(cmailPR, FALSE, CmailSigHandlerCallBack, &cmailISR);
1111     }
1112
1113     ThawUI();
1114     DisplayMessage("", "");
1115     if (StrCaseCmp(appData.initialMode, "") == 0) {
1116       initialMode = BeginningOfGame;
1117     } else if (StrCaseCmp(appData.initialMode, "TwoMachines") == 0) {
1118       initialMode = TwoMachinesPlay;
1119     } else if (StrCaseCmp(appData.initialMode, "AnalyzeFile") == 0) {
1120       initialMode = AnalyzeFile;
1121     } else if (StrCaseCmp(appData.initialMode, "Analysis") == 0) {
1122       initialMode = AnalyzeMode;
1123     } else if (StrCaseCmp(appData.initialMode, "MachineWhite") == 0) {
1124       initialMode = MachinePlaysWhite;
1125     } else if (StrCaseCmp(appData.initialMode, "MachineBlack") == 0) {
1126       initialMode = MachinePlaysBlack;
1127     } else if (StrCaseCmp(appData.initialMode, "EditGame") == 0) {
1128       initialMode = EditGame;
1129     } else if (StrCaseCmp(appData.initialMode, "EditPosition") == 0) {
1130       initialMode = EditPosition;
1131     } else if (StrCaseCmp(appData.initialMode, "Training") == 0) {
1132       initialMode = Training;
1133     } else {
1134       sprintf(buf, _("Unknown initialMode %s"), appData.initialMode);
1135       DisplayFatalError(buf, 0, 2);
1136       return;
1137     }
1138
1139     if (appData.matchMode) {
1140         /* Set up machine vs. machine match */
1141         if (appData.noChessProgram) {
1142             DisplayFatalError(_("Can't have a match with no chess programs"),
1143                               0, 2);
1144             return;
1145         }
1146         matchMode = TRUE;
1147         matchGame = 1;
1148         if (*appData.loadGameFile != NULLCHAR) {
1149             int index = appData.loadGameIndex; // [HGM] autoinc
1150             if(index<0) lastIndex = index = 1;
1151             if (!LoadGameFromFile(appData.loadGameFile,
1152                                   index,
1153                                   appData.loadGameFile, FALSE)) {
1154                 DisplayFatalError(_("Bad game file"), 0, 1);
1155                 return;
1156             }
1157         } else if (*appData.loadPositionFile != NULLCHAR) {
1158             int index = appData.loadPositionIndex; // [HGM] autoinc
1159             if(index<0) lastIndex = index = 1;
1160             if (!LoadPositionFromFile(appData.loadPositionFile,
1161                                       index,
1162                                       appData.loadPositionFile)) {
1163                 DisplayFatalError(_("Bad position file"), 0, 1);
1164                 return;
1165             }
1166         }
1167         TwoMachinesEvent();
1168     } else if (*appData.cmailGameName != NULLCHAR) {
1169         /* Set up cmail mode */
1170         ReloadCmailMsgEvent(TRUE);
1171     } else {
1172         /* Set up other modes */
1173         if (initialMode == AnalyzeFile) {
1174           if (*appData.loadGameFile == NULLCHAR) {
1175             DisplayFatalError(_("AnalyzeFile mode requires a game file"), 0, 1);
1176             return;
1177           }
1178         }
1179         if (*appData.loadGameFile != NULLCHAR) {
1180             (void) LoadGameFromFile(appData.loadGameFile,
1181                                     appData.loadGameIndex,
1182                                     appData.loadGameFile, TRUE);
1183         } else if (*appData.loadPositionFile != NULLCHAR) {
1184             (void) LoadPositionFromFile(appData.loadPositionFile,
1185                                         appData.loadPositionIndex,
1186                                         appData.loadPositionFile);
1187             /* [HGM] try to make self-starting even after FEN load */
1188             /* to allow automatic setup of fairy variants with wtm */
1189             if(initialMode == BeginningOfGame && !blackPlaysFirst) {
1190                 gameMode = BeginningOfGame;
1191                 setboardSpoiledMachineBlack = 1;
1192             }
1193             /* [HGM] loadPos: make that every new game uses the setup */
1194             /* from file as long as we do not switch variant          */
1195             if(!blackPlaysFirst) { int i;
1196                 startedFromPositionFile = TRUE;
1197                 CopyBoard(filePosition, boards[0]);
1198                 for(i=0; i<BOARD_SIZE; i++) fileRights[i] = castlingRights[0][i];
1199             }
1200         }
1201         if (initialMode == AnalyzeMode) {
1202           if (appData.noChessProgram) {
1203             DisplayFatalError(_("Analysis mode requires a chess engine"), 0, 2);
1204             return;
1205           }
1206           if (appData.icsActive) {
1207             DisplayFatalError(_("Analysis mode does not work with ICS mode"),0,2);
1208             return;
1209           }
1210           AnalyzeModeEvent();
1211         } else if (initialMode == AnalyzeFile) {
1212           appData.showThinking = TRUE; // [HGM] thinking: moved out of ShowThinkingEvent
1213           ShowThinkingEvent();
1214           AnalyzeFileEvent();
1215           AnalysisPeriodicEvent(1);
1216         } else if (initialMode == MachinePlaysWhite) {
1217           if (appData.noChessProgram) {
1218             DisplayFatalError(_("MachineWhite mode requires a chess engine"),
1219                               0, 2);
1220             return;
1221           }
1222           if (appData.icsActive) {
1223             DisplayFatalError(_("MachineWhite mode does not work with ICS mode"),
1224                               0, 2);
1225             return;
1226           }
1227           MachineWhiteEvent();
1228         } else if (initialMode == MachinePlaysBlack) {
1229           if (appData.noChessProgram) {
1230             DisplayFatalError(_("MachineBlack mode requires a chess engine"),
1231                               0, 2);
1232             return;
1233           }
1234           if (appData.icsActive) {
1235             DisplayFatalError(_("MachineBlack mode does not work with ICS mode"),
1236                               0, 2);
1237             return;
1238           }
1239           MachineBlackEvent();
1240         } else if (initialMode == TwoMachinesPlay) {
1241           if (appData.noChessProgram) {
1242             DisplayFatalError(_("TwoMachines mode requires a chess engine"),
1243                               0, 2);
1244             return;
1245           }
1246           if (appData.icsActive) {
1247             DisplayFatalError(_("TwoMachines mode does not work with ICS mode"),
1248                               0, 2);
1249             return;
1250           }
1251           TwoMachinesEvent();
1252         } else if (initialMode == EditGame) {
1253           EditGameEvent();
1254         } else if (initialMode == EditPosition) {
1255           EditPositionEvent();
1256         } else if (initialMode == Training) {
1257           if (*appData.loadGameFile == NULLCHAR) {
1258             DisplayFatalError(_("Training mode requires a game file"), 0, 2);
1259             return;
1260           }
1261           TrainingEvent();
1262         }
1263     }
1264 }
1265
1266 /*
1267  * Establish will establish a contact to a remote host.port.
1268  * Sets icsPR to a ProcRef for a process (or pseudo-process)
1269  *  used to talk to the host.
1270  * Returns 0 if okay, error code if not.
1271  */
1272 int
1273 establish()
1274 {
1275     char buf[MSG_SIZ];
1276
1277     if (*appData.icsCommPort != NULLCHAR) {
1278         /* Talk to the host through a serial comm port */
1279         return OpenCommPort(appData.icsCommPort, &icsPR);
1280
1281     } else if (*appData.gateway != NULLCHAR) {
1282         if (*appData.remoteShell == NULLCHAR) {
1283             /* Use the rcmd protocol to run telnet program on a gateway host */
1284             snprintf(buf, sizeof(buf), "%s %s %s",
1285                     appData.telnetProgram, appData.icsHost, appData.icsPort);
1286             return OpenRcmd(appData.gateway, appData.remoteUser, buf, &icsPR);
1287
1288         } else {
1289             /* Use the rsh program to run telnet program on a gateway host */
1290             if (*appData.remoteUser == NULLCHAR) {
1291                 snprintf(buf, sizeof(buf), "%s %s %s %s %s", appData.remoteShell,
1292                         appData.gateway, appData.telnetProgram,
1293                         appData.icsHost, appData.icsPort);
1294             } else {
1295                 snprintf(buf, sizeof(buf), "%s %s -l %s %s %s %s",
1296                         appData.remoteShell, appData.gateway,
1297                         appData.remoteUser, appData.telnetProgram,
1298                         appData.icsHost, appData.icsPort);
1299             }
1300             return StartChildProcess(buf, "", &icsPR);
1301
1302         }
1303     } else if (appData.useTelnet) {
1304         return OpenTelnet(appData.icsHost, appData.icsPort, &icsPR);
1305
1306     } else {
1307         /* TCP socket interface differs somewhat between
1308            Unix and NT; handle details in the front end.
1309            */
1310         return OpenTCP(appData.icsHost, appData.icsPort, &icsPR);
1311     }
1312 }
1313
1314 void
1315 show_bytes(fp, buf, count)
1316      FILE *fp;
1317      char *buf;
1318      int count;
1319 {
1320     while (count--) {
1321         if (*buf < 040 || *(unsigned char *) buf > 0177) {
1322             fprintf(fp, "\\%03o", *buf & 0xff);
1323         } else {
1324             putc(*buf, fp);
1325         }
1326         buf++;
1327     }
1328     fflush(fp);
1329 }
1330
1331 /* Returns an errno value */
1332 int
1333 OutputMaybeTelnet(pr, message, count, outError)
1334      ProcRef pr;
1335      char *message;
1336      int count;
1337      int *outError;
1338 {
1339     char buf[8192], *p, *q, *buflim;
1340     int left, newcount, outcount;
1341
1342     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet ||
1343         *appData.gateway != NULLCHAR) {
1344         if (appData.debugMode) {
1345             fprintf(debugFP, ">ICS: ");
1346             show_bytes(debugFP, message, count);
1347             fprintf(debugFP, "\n");
1348         }
1349         return OutputToProcess(pr, message, count, outError);
1350     }
1351
1352     buflim = &buf[sizeof(buf)-1]; /* allow 1 byte for expanding last char */
1353     p = message;
1354     q = buf;
1355     left = count;
1356     newcount = 0;
1357     while (left) {
1358         if (q >= buflim) {
1359             if (appData.debugMode) {
1360                 fprintf(debugFP, ">ICS: ");
1361                 show_bytes(debugFP, buf, newcount);
1362                 fprintf(debugFP, "\n");
1363             }
1364             outcount = OutputToProcess(pr, buf, newcount, outError);
1365             if (outcount < newcount) return -1; /* to be sure */
1366             q = buf;
1367             newcount = 0;
1368         }
1369         if (*p == '\n') {
1370             *q++ = '\r';
1371             newcount++;
1372         } else if (((unsigned char) *p) == TN_IAC) {
1373             *q++ = (char) TN_IAC;
1374             newcount ++;
1375         }
1376         *q++ = *p++;
1377         newcount++;
1378         left--;
1379     }
1380     if (appData.debugMode) {
1381         fprintf(debugFP, ">ICS: ");
1382         show_bytes(debugFP, buf, newcount);
1383         fprintf(debugFP, "\n");
1384     }
1385     outcount = OutputToProcess(pr, buf, newcount, outError);
1386     if (outcount < newcount) return -1; /* to be sure */
1387     return count;
1388 }
1389
1390 void
1391 read_from_player(isr, closure, message, count, error)
1392      InputSourceRef isr;
1393      VOIDSTAR closure;
1394      char *message;
1395      int count;
1396      int error;
1397 {
1398     int outError, outCount;
1399     static int gotEof = 0;
1400
1401     /* Pass data read from player on to ICS */
1402     if (count > 0) {
1403         gotEof = 0;
1404         outCount = OutputMaybeTelnet(icsPR, message, count, &outError);
1405         if (outCount < count) {
1406             DisplayFatalError(_("Error writing to ICS"), outError, 1);
1407         }
1408     } else if (count < 0) {
1409         RemoveInputSource(isr);
1410         DisplayFatalError(_("Error reading from keyboard"), error, 1);
1411     } else if (gotEof++ > 0) {
1412         RemoveInputSource(isr);
1413         DisplayFatalError(_("Got end of file from keyboard"), 0, 0);
1414     }
1415 }
1416
1417 void
1418 KeepAlive()
1419 {   // [HGM] alive: periodically send dummy (date) command to ICS to prevent time-out
1420     SendToICS("date\n");
1421     if(appData.keepAlive) ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1422 }
1423
1424 /* added routine for printf style output to ics */
1425 void ics_printf(char *format, ...)
1426 {
1427     char buffer[MSG_SIZ];
1428     va_list args;
1429
1430     va_start(args, format);
1431     vsnprintf(buffer, sizeof(buffer), format, args);
1432     buffer[sizeof(buffer)-1] = '\0';
1433     SendToICS(buffer);
1434     va_end(args);
1435 }
1436
1437 void
1438 SendToICS(s)
1439      char *s;
1440 {
1441     int count, outCount, outError;
1442
1443     if (icsPR == NULL) return;
1444
1445     count = strlen(s);
1446     outCount = OutputMaybeTelnet(icsPR, s, count, &outError);
1447     if (outCount < count) {
1448         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1449     }
1450 }
1451
1452 /* This is used for sending logon scripts to the ICS. Sending
1453    without a delay causes problems when using timestamp on ICC
1454    (at least on my machine). */
1455 void
1456 SendToICSDelayed(s,msdelay)
1457      char *s;
1458      long msdelay;
1459 {
1460     int count, outCount, outError;
1461
1462     if (icsPR == NULL) return;
1463
1464     count = strlen(s);
1465     if (appData.debugMode) {
1466         fprintf(debugFP, ">ICS: ");
1467         show_bytes(debugFP, s, count);
1468         fprintf(debugFP, "\n");
1469     }
1470     outCount = OutputToProcessDelayed(icsPR, s, count, &outError,
1471                                       msdelay);
1472     if (outCount < count) {
1473         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1474     }
1475 }
1476
1477
1478 /* Remove all highlighting escape sequences in s
1479    Also deletes any suffix starting with '('
1480    */
1481 char *
1482 StripHighlightAndTitle(s)
1483      char *s;
1484 {
1485     static char retbuf[MSG_SIZ];
1486     char *p = retbuf;
1487
1488     while (*s != NULLCHAR) {
1489         while (*s == '\033') {
1490             while (*s != NULLCHAR && !isalpha(*s)) s++;
1491             if (*s != NULLCHAR) s++;
1492         }
1493         while (*s != NULLCHAR && *s != '\033') {
1494             if (*s == '(' || *s == '[') {
1495                 *p = NULLCHAR;
1496                 return retbuf;
1497             }
1498             *p++ = *s++;
1499         }
1500     }
1501     *p = NULLCHAR;
1502     return retbuf;
1503 }
1504
1505 /* Remove all highlighting escape sequences in s */
1506 char *
1507 StripHighlight(s)
1508      char *s;
1509 {
1510     static char retbuf[MSG_SIZ];
1511     char *p = retbuf;
1512
1513     while (*s != NULLCHAR) {
1514         while (*s == '\033') {
1515             while (*s != NULLCHAR && !isalpha(*s)) s++;
1516             if (*s != NULLCHAR) s++;
1517         }
1518         while (*s != NULLCHAR && *s != '\033') {
1519             *p++ = *s++;
1520         }
1521     }
1522     *p = NULLCHAR;
1523     return retbuf;
1524 }
1525
1526 char *variantNames[] = VARIANT_NAMES;
1527 char *
1528 VariantName(v)
1529      VariantClass v;
1530 {
1531     return variantNames[v];
1532 }
1533
1534
1535 /* Identify a variant from the strings the chess servers use or the
1536    PGN Variant tag names we use. */
1537 VariantClass
1538 StringToVariant(e)
1539      char *e;
1540 {
1541     char *p;
1542     int wnum = -1;
1543     VariantClass v = VariantNormal;
1544     int i, found = FALSE;
1545     char buf[MSG_SIZ];
1546
1547     if (!e) return v;
1548
1549     /* [HGM] skip over optional board-size prefixes */
1550     if( sscanf(e, "%dx%d_", &i, &i) == 2 ||
1551         sscanf(e, "%dx%d+%d_", &i, &i, &i) == 3 ) {
1552         while( *e++ != '_');
1553     }
1554
1555     if(StrCaseStr(e, "misc/")) { // [HGM] on FICS, misc/shogi is not shogi
1556         v = VariantNormal;
1557         found = TRUE;
1558     } else
1559     for (i=0; i<sizeof(variantNames)/sizeof(char*); i++) {
1560       if (StrCaseStr(e, variantNames[i])) {
1561         v = (VariantClass) i;
1562         found = TRUE;
1563         break;
1564       }
1565     }
1566
1567     if (!found) {
1568       if ((StrCaseStr(e, "fischer") && StrCaseStr(e, "random"))
1569           || StrCaseStr(e, "wild/fr")
1570           || StrCaseStr(e, "frc") || StrCaseStr(e, "960")) {
1571         v = VariantFischeRandom;
1572       } else if ((i = 4, p = StrCaseStr(e, "wild")) ||
1573                  (i = 1, p = StrCaseStr(e, "w"))) {
1574         p += i;
1575         while (*p && (isspace(*p) || *p == '(' || *p == '/')) p++;
1576         if (isdigit(*p)) {
1577           wnum = atoi(p);
1578         } else {
1579           wnum = -1;
1580         }
1581         switch (wnum) {
1582         case 0: /* FICS only, actually */
1583         case 1:
1584           /* Castling legal even if K starts on d-file */
1585           v = VariantWildCastle;
1586           break;
1587         case 2:
1588         case 3:
1589         case 4:
1590           /* Castling illegal even if K & R happen to start in
1591              normal positions. */
1592           v = VariantNoCastle;
1593           break;
1594         case 5:
1595         case 7:
1596         case 8:
1597         case 10:
1598         case 11:
1599         case 12:
1600         case 13:
1601         case 14:
1602         case 15:
1603         case 18:
1604         case 19:
1605           /* Castling legal iff K & R start in normal positions */
1606           v = VariantNormal;
1607           break;
1608         case 6:
1609         case 20:
1610         case 21:
1611           /* Special wilds for position setup; unclear what to do here */
1612           v = VariantLoadable;
1613           break;
1614         case 9:
1615           /* Bizarre ICC game */
1616           v = VariantTwoKings;
1617           break;
1618         case 16:
1619           v = VariantKriegspiel;
1620           break;
1621         case 17:
1622           v = VariantLosers;
1623           break;
1624         case 22:
1625           v = VariantFischeRandom;
1626           break;
1627         case 23:
1628           v = VariantCrazyhouse;
1629           break;
1630         case 24:
1631           v = VariantBughouse;
1632           break;
1633         case 25:
1634           v = Variant3Check;
1635           break;
1636         case 26:
1637           /* Not quite the same as FICS suicide! */
1638           v = VariantGiveaway;
1639           break;
1640         case 27:
1641           v = VariantAtomic;
1642           break;
1643         case 28:
1644           v = VariantShatranj;
1645           break;
1646
1647         /* Temporary names for future ICC types.  The name *will* change in
1648            the next xboard/WinBoard release after ICC defines it. */
1649         case 29:
1650           v = Variant29;
1651           break;
1652         case 30:
1653           v = Variant30;
1654           break;
1655         case 31:
1656           v = Variant31;
1657           break;
1658         case 32:
1659           v = Variant32;
1660           break;
1661         case 33:
1662           v = Variant33;
1663           break;
1664         case 34:
1665           v = Variant34;
1666           break;
1667         case 35:
1668           v = Variant35;
1669           break;
1670         case 36:
1671           v = Variant36;
1672           break;
1673         case 37:
1674           v = VariantShogi;
1675           break;
1676         case 38:
1677           v = VariantXiangqi;
1678           break;
1679         case 39:
1680           v = VariantCourier;
1681           break;
1682         case 40:
1683           v = VariantGothic;
1684           break;
1685         case 41:
1686           v = VariantCapablanca;
1687           break;
1688         case 42:
1689           v = VariantKnightmate;
1690           break;
1691         case 43:
1692           v = VariantFairy;
1693           break;
1694         case 44:
1695           v = VariantCylinder;
1696           break;
1697         case 45:
1698           v = VariantFalcon;
1699           break;
1700         case 46:
1701           v = VariantCapaRandom;
1702           break;
1703         case 47:
1704           v = VariantBerolina;
1705           break;
1706         case 48:
1707           v = VariantJanus;
1708           break;
1709         case 49:
1710           v = VariantSuper;
1711           break;
1712         case 50:
1713           v = VariantGreat;
1714           break;
1715         case -1:
1716           /* Found "wild" or "w" in the string but no number;
1717              must assume it's normal chess. */
1718           v = VariantNormal;
1719           break;
1720         default:
1721           sprintf(buf, _("Unknown wild type %d"), wnum);
1722           DisplayError(buf, 0);
1723           v = VariantUnknown;
1724           break;
1725         }
1726       }
1727     }
1728     if (appData.debugMode) {
1729       fprintf(debugFP, _("recognized '%s' (%d) as variant %s\n"),
1730               e, wnum, VariantName(v));
1731     }
1732     return v;
1733 }
1734
1735 static int leftover_start = 0, leftover_len = 0;
1736 char star_match[STAR_MATCH_N][MSG_SIZ];
1737
1738 /* Test whether pattern is present at &buf[*index]; if so, return TRUE,
1739    advance *index beyond it, and set leftover_start to the new value of
1740    *index; else return FALSE.  If pattern contains the character '*', it
1741    matches any sequence of characters not containing '\r', '\n', or the
1742    character following the '*' (if any), and the matched sequence(s) are
1743    copied into star_match.
1744    */
1745 int
1746 looking_at(buf, index, pattern)
1747      char *buf;
1748      int *index;
1749      char *pattern;
1750 {
1751     char *bufp = &buf[*index], *patternp = pattern;
1752     int star_count = 0;
1753     char *matchp = star_match[0];
1754
1755     for (;;) {
1756         if (*patternp == NULLCHAR) {
1757             *index = leftover_start = bufp - buf;
1758             *matchp = NULLCHAR;
1759             return TRUE;
1760         }
1761         if (*bufp == NULLCHAR) return FALSE;
1762         if (*patternp == '*') {
1763             if (*bufp == *(patternp + 1)) {
1764                 *matchp = NULLCHAR;
1765                 matchp = star_match[++star_count];
1766                 patternp += 2;
1767                 bufp++;
1768                 continue;
1769             } else if (*bufp == '\n' || *bufp == '\r') {
1770                 patternp++;
1771                 if (*patternp == NULLCHAR)
1772                   continue;
1773                 else
1774                   return FALSE;
1775             } else {
1776                 *matchp++ = *bufp++;
1777                 continue;
1778             }
1779         }
1780         if (*patternp != *bufp) return FALSE;
1781         patternp++;
1782         bufp++;
1783     }
1784 }
1785
1786 void
1787 SendToPlayer(data, length)
1788      char *data;
1789      int length;
1790 {
1791     int error, outCount;
1792     outCount = OutputToProcess(NoProc, data, length, &error);
1793     if (outCount < length) {
1794         DisplayFatalError(_("Error writing to display"), error, 1);
1795     }
1796 }
1797
1798 void
1799 PackHolding(packed, holding)
1800      char packed[];
1801      char *holding;
1802 {
1803     char *p = holding;
1804     char *q = packed;
1805     int runlength = 0;
1806     int curr = 9999;
1807     do {
1808         if (*p == curr) {
1809             runlength++;
1810         } else {
1811             switch (runlength) {
1812               case 0:
1813                 break;
1814               case 1:
1815                 *q++ = curr;
1816                 break;
1817               case 2:
1818                 *q++ = curr;
1819                 *q++ = curr;
1820                 break;
1821               default:
1822                 sprintf(q, "%d", runlength);
1823                 while (*q) q++;
1824                 *q++ = curr;
1825                 break;
1826             }
1827             runlength = 1;
1828             curr = *p;
1829         }
1830     } while (*p++);
1831     *q = NULLCHAR;
1832 }
1833
1834 /* Telnet protocol requests from the front end */
1835 void
1836 TelnetRequest(ddww, option)
1837      unsigned char ddww, option;
1838 {
1839     unsigned char msg[3];
1840     int outCount, outError;
1841
1842     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet) return;
1843
1844     if (appData.debugMode) {
1845         char buf1[8], buf2[8], *ddwwStr, *optionStr;
1846         switch (ddww) {
1847           case TN_DO:
1848             ddwwStr = "DO";
1849             break;
1850           case TN_DONT:
1851             ddwwStr = "DONT";
1852             break;
1853           case TN_WILL:
1854             ddwwStr = "WILL";
1855             break;
1856           case TN_WONT:
1857             ddwwStr = "WONT";
1858             break;
1859           default:
1860             ddwwStr = buf1;
1861             sprintf(buf1, "%d", ddww);
1862             break;
1863         }
1864         switch (option) {
1865           case TN_ECHO:
1866             optionStr = "ECHO";
1867             break;
1868           default:
1869             optionStr = buf2;
1870             sprintf(buf2, "%d", option);
1871             break;
1872         }
1873         fprintf(debugFP, ">%s %s ", ddwwStr, optionStr);
1874     }
1875     msg[0] = TN_IAC;
1876     msg[1] = ddww;
1877     msg[2] = option;
1878     outCount = OutputToProcess(icsPR, (char *)msg, 3, &outError);
1879     if (outCount < 3) {
1880         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1881     }
1882 }
1883
1884 void
1885 DoEcho()
1886 {
1887     if (!appData.icsActive) return;
1888     TelnetRequest(TN_DO, TN_ECHO);
1889 }
1890
1891 void
1892 DontEcho()
1893 {
1894     if (!appData.icsActive) return;
1895     TelnetRequest(TN_DONT, TN_ECHO);
1896 }
1897
1898 void
1899 CopyHoldings(Board board, char *holdings, ChessSquare lowestPiece)
1900 {
1901     /* put the holdings sent to us by the server on the board holdings area */
1902     int i, j, holdingsColumn, holdingsStartRow, direction, countsColumn;
1903     char p;
1904     ChessSquare piece;
1905
1906     if(gameInfo.holdingsWidth < 2)  return;
1907
1908     if( (int)lowestPiece >= BlackPawn ) {
1909         holdingsColumn = 0;
1910         countsColumn = 1;
1911         holdingsStartRow = BOARD_HEIGHT-1;
1912         direction = -1;
1913     } else {
1914         holdingsColumn = BOARD_WIDTH-1;
1915         countsColumn = BOARD_WIDTH-2;
1916         holdingsStartRow = 0;
1917         direction = 1;
1918     }
1919
1920     for(i=0; i<BOARD_HEIGHT; i++) { /* clear holdings */
1921         board[i][holdingsColumn] = EmptySquare;
1922         board[i][countsColumn]   = (ChessSquare) 0;
1923     }
1924     while( (p=*holdings++) != NULLCHAR ) {
1925         piece = CharToPiece( ToUpper(p) );
1926         if(piece == EmptySquare) continue;
1927         /*j = (int) piece - (int) WhitePawn;*/
1928         j = PieceToNumber(piece);
1929         if(j >= gameInfo.holdingsSize) continue; /* ignore pieces that do not fit */
1930         if(j < 0) continue;               /* should not happen */
1931         piece = (ChessSquare) ( (int)piece + (int)lowestPiece );
1932         board[holdingsStartRow+j*direction][holdingsColumn] = piece;
1933         board[holdingsStartRow+j*direction][countsColumn]++;
1934     }
1935
1936 }
1937
1938
1939 void
1940 VariantSwitch(Board board, VariantClass newVariant)
1941 {
1942    int newHoldingsWidth, newWidth = 8, newHeight = 8, i, j;
1943
1944    startedFromPositionFile = FALSE;
1945    if(gameInfo.variant == newVariant) return;
1946
1947    /* [HGM] This routine is called each time an assignment is made to
1948     * gameInfo.variant during a game, to make sure the board sizes
1949     * are set to match the new variant. If that means adding or deleting
1950     * holdings, we shift the playing board accordingly
1951     * This kludge is needed because in ICS observe mode, we get boards
1952     * of an ongoing game without knowing the variant, and learn about the
1953     * latter only later. This can be because of the move list we requested,
1954     * in which case the game history is refilled from the beginning anyway,
1955     * but also when receiving holdings of a crazyhouse game. In the latter
1956     * case we want to add those holdings to the already received position.
1957     */
1958
1959
1960    if (appData.debugMode) {
1961      fprintf(debugFP, "Switch board from %s to %s\n",
1962              VariantName(gameInfo.variant), VariantName(newVariant));
1963      setbuf(debugFP, NULL);
1964    }
1965    shuffleOpenings = 0;       /* [HGM] shuffle */
1966    gameInfo.holdingsSize = 5; /* [HGM] prepare holdings */
1967    switch(newVariant)
1968      {
1969      case VariantShogi:
1970        newWidth = 9;  newHeight = 9;
1971        gameInfo.holdingsSize = 7;
1972      case VariantBughouse:
1973      case VariantCrazyhouse:
1974        newHoldingsWidth = 2; break;
1975      case VariantGreat:
1976        newWidth = 10;
1977      case VariantSuper:
1978        newHoldingsWidth = 2;
1979        gameInfo.holdingsSize = 8;
1980        return;
1981      case VariantGothic:
1982      case VariantCapablanca:
1983      case VariantCapaRandom:
1984        newWidth = 10;
1985      default:
1986        newHoldingsWidth = gameInfo.holdingsSize = 0;
1987      };
1988
1989    if(newWidth  != gameInfo.boardWidth  ||
1990       newHeight != gameInfo.boardHeight ||
1991       newHoldingsWidth != gameInfo.holdingsWidth ) {
1992
1993      /* shift position to new playing area, if needed */
1994      if(newHoldingsWidth > gameInfo.holdingsWidth) {
1995        for(i=0; i<BOARD_HEIGHT; i++)
1996          for(j=BOARD_RGHT-1; j>=BOARD_LEFT; j--)
1997            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
1998              board[i][j];
1999        for(i=0; i<newHeight; i++) {
2000          board[i][0] = board[i][newWidth+2*newHoldingsWidth-1] = EmptySquare;
2001          board[i][1] = board[i][newWidth+2*newHoldingsWidth-2] = (ChessSquare) 0;
2002        }
2003      } else if(newHoldingsWidth < gameInfo.holdingsWidth) {
2004        for(i=0; i<BOARD_HEIGHT; i++)
2005          for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
2006            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2007              board[i][j];
2008      }
2009      gameInfo.boardWidth  = newWidth;
2010      gameInfo.boardHeight = newHeight;
2011      gameInfo.holdingsWidth = newHoldingsWidth;
2012      gameInfo.variant = newVariant;
2013      InitDrawingSizes(-2, 0);
2014      InitPosition(FALSE);          /* this sets up board[0], but also other stuff        */
2015    } else { gameInfo.variant = newVariant; InitPosition(FALSE); }
2016
2017    DrawPosition(TRUE, boards[currentMove]);
2018 }
2019
2020 static int loggedOn = FALSE;
2021
2022 /*-- Game start info cache: --*/
2023 int gs_gamenum;
2024 char gs_kind[MSG_SIZ];
2025 static char player1Name[128] = "";
2026 static char player2Name[128] = "";
2027 static char cont_seq[] = "\n\\   ";
2028 static int player1Rating = -1;
2029 static int player2Rating = -1;
2030 /*----------------------------*/
2031
2032 ColorClass curColor = ColorNormal;
2033 int suppressKibitz = 0;
2034
2035 void
2036 read_from_ics(isr, closure, data, count, error)
2037      InputSourceRef isr;
2038      VOIDSTAR closure;
2039      char *data;
2040      int count;
2041      int error;
2042 {
2043 #define BUF_SIZE 8192
2044 #define STARTED_NONE 0
2045 #define STARTED_MOVES 1
2046 #define STARTED_BOARD 2
2047 #define STARTED_OBSERVE 3
2048 #define STARTED_HOLDINGS 4
2049 #define STARTED_CHATTER 5
2050 #define STARTED_COMMENT 6
2051 #define STARTED_MOVES_NOHIDE 7
2052
2053     static int started = STARTED_NONE;
2054     static char parse[20000];
2055     static int parse_pos = 0;
2056     static char buf[BUF_SIZE + 1];
2057     static int firstTime = TRUE, intfSet = FALSE;
2058     static ColorClass prevColor = ColorNormal;
2059     static int savingComment = FALSE;
2060     static int cmatch = 0; // continuation sequence match
2061     char *bp;
2062     char str[500];
2063     int i, oldi;
2064     int buf_len;
2065     int next_out;
2066     int tkind;
2067     int backup;    /* [DM] For zippy color lines */
2068     char *p;
2069     char talker[MSG_SIZ]; // [HGM] chat
2070     int channel;
2071
2072     if (appData.debugMode) {
2073       if (!error) {
2074         fprintf(debugFP, "<ICS: ");
2075         show_bytes(debugFP, data, count);
2076         fprintf(debugFP, "\n");
2077       }
2078     }
2079
2080     if (appData.debugMode) { int f = forwardMostMove;
2081         fprintf(debugFP, "ics input %d, castling = %d %d %d %d %d %d\n", f,
2082                 castlingRights[f][0],castlingRights[f][1],castlingRights[f][2],castlingRights[f][3],castlingRights[f][4],castlingRights[f][5]);
2083     }
2084     if (count > 0) {
2085         /* If last read ended with a partial line that we couldn't parse,
2086            prepend it to the new read and try again. */
2087         if (leftover_len > 0) {
2088             for (i=0; i<leftover_len; i++)
2089               buf[i] = buf[leftover_start + i];
2090         }
2091
2092     /* copy new characters into the buffer */
2093     bp = buf + leftover_len;
2094     buf_len=leftover_len;
2095     for (i=0; i<count; i++)
2096     {
2097         // ignore these
2098         if (data[i] == '\r')
2099             continue;
2100
2101         // join lines split by ICS?
2102         if (!appData.noJoin)
2103         {
2104             /*
2105                 Joining just consists of finding matches against the
2106                 continuation sequence, and discarding that sequence
2107                 if found instead of copying it.  So, until a match
2108                 fails, there's nothing to do since it might be the
2109                 complete sequence, and thus, something we don't want
2110                 copied.
2111             */
2112             if (data[i] == cont_seq[cmatch])
2113             {
2114                 cmatch++;
2115                 if (cmatch == strlen(cont_seq))
2116                 {
2117                     cmatch = 0; // complete match.  just reset the counter
2118
2119                     /*
2120                         it's possible for the ICS to not include the space
2121                         at the end of the last word, making our [correct]
2122                         join operation fuse two separate words.  the server
2123                         does this when the space occurs at the width setting.
2124                     */
2125                     if (!buf_len || buf[buf_len-1] != ' ')
2126                     {
2127                         *bp++ = ' ';
2128                         buf_len++;
2129                     }
2130                 }
2131                 continue;
2132             }
2133             else if (cmatch)
2134             {
2135                 /*
2136                     match failed, so we have to copy what matched before
2137                     falling through and copying this character.  In reality,
2138                     this will only ever be just the newline character, but
2139                     it doesn't hurt to be precise.
2140                 */
2141                 strncpy(bp, cont_seq, cmatch);
2142                 bp += cmatch;
2143                 buf_len += cmatch;
2144                 cmatch = 0;
2145             }
2146         }
2147
2148         // copy this char
2149         *bp++ = data[i];
2150         buf_len++;
2151     }
2152
2153         buf[buf_len] = NULLCHAR;
2154         next_out = leftover_len;
2155         leftover_start = 0;
2156
2157         i = 0;
2158         while (i < buf_len) {
2159             /* Deal with part of the TELNET option negotiation
2160                protocol.  We refuse to do anything beyond the
2161                defaults, except that we allow the WILL ECHO option,
2162                which ICS uses to turn off password echoing when we are
2163                directly connected to it.  We reject this option
2164                if localLineEditing mode is on (always on in xboard)
2165                and we are talking to port 23, which might be a real
2166                telnet server that will try to keep WILL ECHO on permanently.
2167              */
2168             if (buf_len - i >= 3 && (unsigned char) buf[i] == TN_IAC) {
2169                 static int remoteEchoOption = FALSE; /* telnet ECHO option */
2170                 unsigned char option;
2171                 oldi = i;
2172                 switch ((unsigned char) buf[++i]) {
2173                   case TN_WILL:
2174                     if (appData.debugMode)
2175                       fprintf(debugFP, "\n<WILL ");
2176                     switch (option = (unsigned char) buf[++i]) {
2177                       case TN_ECHO:
2178                         if (appData.debugMode)
2179                           fprintf(debugFP, "ECHO ");
2180                         /* Reply only if this is a change, according
2181                            to the protocol rules. */
2182                         if (remoteEchoOption) break;
2183                         if (appData.localLineEditing &&
2184                             atoi(appData.icsPort) == TN_PORT) {
2185                             TelnetRequest(TN_DONT, TN_ECHO);
2186                         } else {
2187                             EchoOff();
2188                             TelnetRequest(TN_DO, TN_ECHO);
2189                             remoteEchoOption = TRUE;
2190                         }
2191                         break;
2192                       default:
2193                         if (appData.debugMode)
2194                           fprintf(debugFP, "%d ", option);
2195                         /* Whatever this is, we don't want it. */
2196                         TelnetRequest(TN_DONT, option);
2197                         break;
2198                     }
2199                     break;
2200                   case TN_WONT:
2201                     if (appData.debugMode)
2202                       fprintf(debugFP, "\n<WONT ");
2203                     switch (option = (unsigned char) buf[++i]) {
2204                       case TN_ECHO:
2205                         if (appData.debugMode)
2206                           fprintf(debugFP, "ECHO ");
2207                         /* Reply only if this is a change, according
2208                            to the protocol rules. */
2209                         if (!remoteEchoOption) break;
2210                         EchoOn();
2211                         TelnetRequest(TN_DONT, TN_ECHO);
2212                         remoteEchoOption = FALSE;
2213                         break;
2214                       default:
2215                         if (appData.debugMode)
2216                           fprintf(debugFP, "%d ", (unsigned char) option);
2217                         /* Whatever this is, it must already be turned
2218                            off, because we never agree to turn on
2219                            anything non-default, so according to the
2220                            protocol rules, we don't reply. */
2221                         break;
2222                     }
2223                     break;
2224                   case TN_DO:
2225                     if (appData.debugMode)
2226                       fprintf(debugFP, "\n<DO ");
2227                     switch (option = (unsigned char) buf[++i]) {
2228                       default:
2229                         /* Whatever this is, we refuse to do it. */
2230                         if (appData.debugMode)
2231                           fprintf(debugFP, "%d ", option);
2232                         TelnetRequest(TN_WONT, option);
2233                         break;
2234                     }
2235                     break;
2236                   case TN_DONT:
2237                     if (appData.debugMode)
2238                       fprintf(debugFP, "\n<DONT ");
2239                     switch (option = (unsigned char) buf[++i]) {
2240                       default:
2241                         if (appData.debugMode)
2242                           fprintf(debugFP, "%d ", option);
2243                         /* Whatever this is, we are already not doing
2244                            it, because we never agree to do anything
2245                            non-default, so according to the protocol
2246                            rules, we don't reply. */
2247                         break;
2248                     }
2249                     break;
2250                   case TN_IAC:
2251                     if (appData.debugMode)
2252                       fprintf(debugFP, "\n<IAC ");
2253                     /* Doubled IAC; pass it through */
2254                     i--;
2255                     break;
2256                   default:
2257                     if (appData.debugMode)
2258                       fprintf(debugFP, "\n<%d ", (unsigned char) buf[i]);
2259                     /* Drop all other telnet commands on the floor */
2260                     break;
2261                 }
2262                 if (oldi > next_out)
2263                   SendToPlayer(&buf[next_out], oldi - next_out);
2264                 if (++i > next_out)
2265                   next_out = i;
2266                 continue;
2267             }
2268
2269             /* OK, this at least will *usually* work */
2270             if (!loggedOn && looking_at(buf, &i, "ics%")) {
2271                 loggedOn = TRUE;
2272             }
2273
2274             if (loggedOn && !intfSet) {
2275                 if (ics_type == ICS_ICC) {
2276                   sprintf(str,
2277                           "/set-quietly interface %s\n/set-quietly style 12\n",
2278                           programVersion);
2279                 } else if (ics_type == ICS_CHESSNET) {
2280                   sprintf(str, "/style 12\n");
2281                 } else {
2282                   strcpy(str, "alias $ @\n$set interface ");
2283                   strcat(str, programVersion);
2284                   strcat(str, "\n$iset startpos 1\n$iset ms 1\n");
2285 #ifdef WIN32
2286                   strcat(str, "$iset nohighlight 1\n");
2287 #endif
2288                   strcat(str, "$iset lock 1\n$style 12\n");
2289                 }
2290                 SendToICS(str);
2291                 NotifyFrontendLogin();
2292                 intfSet = TRUE;
2293             }
2294
2295             if (started == STARTED_COMMENT) {
2296                 /* Accumulate characters in comment */
2297                 parse[parse_pos++] = buf[i];
2298                 if (buf[i] == '\n') {
2299                     parse[parse_pos] = NULLCHAR;
2300                     if(chattingPartner>=0) {
2301                         char mess[MSG_SIZ];
2302                         sprintf(mess, "%s%s", talker, parse);
2303                         OutputChatMessage(chattingPartner, mess);
2304                         chattingPartner = -1;
2305                     } else
2306                     if(!suppressKibitz) // [HGM] kibitz
2307                         AppendComment(forwardMostMove, StripHighlight(parse));
2308                     else { // [HGM kibitz: divert memorized engine kibitz to engine-output window
2309                         int nrDigit = 0, nrAlph = 0, i;
2310                         if(parse_pos > MSG_SIZ - 30) // defuse unreasonably long input
2311                         { parse_pos = MSG_SIZ-30; parse[parse_pos - 1] = '\n'; }
2312                         parse[parse_pos] = NULLCHAR;
2313                         // try to be smart: if it does not look like search info, it should go to
2314                         // ICS interaction window after all, not to engine-output window.
2315                         for(i=0; i<parse_pos; i++) { // count letters and digits
2316                             nrDigit += (parse[i] >= '0' && parse[i] <= '9');
2317                             nrAlph  += (parse[i] >= 'a' && parse[i] <= 'z');
2318                             nrAlph  += (parse[i] >= 'A' && parse[i] <= 'Z');
2319                         }
2320                         if(nrAlph < 9*nrDigit) { // if more than 10% digit we assume search info
2321                             int depth=0; float score;
2322                             if(sscanf(parse, "!!! %f/%d", &score, &depth) == 2 && depth>0) {
2323                                 // [HGM] kibitz: save kibitzed opponent info for PGN and eval graph
2324                                 pvInfoList[forwardMostMove-1].depth = depth;
2325                                 pvInfoList[forwardMostMove-1].score = 100*score;
2326                             }
2327                             OutputKibitz(suppressKibitz, parse);
2328                         } else {
2329                             char tmp[MSG_SIZ];
2330                             sprintf(tmp, _("your opponent kibitzes: %s"), parse);
2331                             SendToPlayer(tmp, strlen(tmp));
2332                         }
2333                     }
2334                     started = STARTED_NONE;
2335                 } else {
2336                     /* Don't match patterns against characters in chatter */
2337                     i++;
2338                     continue;
2339                 }
2340             }
2341             if (started == STARTED_CHATTER) {
2342                 if (buf[i] != '\n') {
2343                     /* Don't match patterns against characters in chatter */
2344                     i++;
2345                     continue;
2346                 }
2347                 started = STARTED_NONE;
2348             }
2349
2350             /* Kludge to deal with rcmd protocol */
2351             if (firstTime && looking_at(buf, &i, "\001*")) {
2352                 DisplayFatalError(&buf[1], 0, 1);
2353                 continue;
2354             } else {
2355                 firstTime = FALSE;
2356             }
2357
2358             if (!loggedOn && looking_at(buf, &i, "chessclub.com")) {
2359                 ics_type = ICS_ICC;
2360                 ics_prefix = "/";
2361                 if (appData.debugMode)
2362                   fprintf(debugFP, "ics_type %d\n", ics_type);
2363                 continue;
2364             }
2365             if (!loggedOn && looking_at(buf, &i, "freechess.org")) {
2366                 ics_type = ICS_FICS;
2367                 ics_prefix = "$";
2368                 if (appData.debugMode)
2369                   fprintf(debugFP, "ics_type %d\n", ics_type);
2370                 continue;
2371             }
2372             if (!loggedOn && looking_at(buf, &i, "chess.net")) {
2373                 ics_type = ICS_CHESSNET;
2374                 ics_prefix = "/";
2375                 if (appData.debugMode)
2376                   fprintf(debugFP, "ics_type %d\n", ics_type);
2377                 continue;
2378             }
2379
2380             if (!loggedOn &&
2381                 (looking_at(buf, &i, "\"*\" is *a registered name") ||
2382                  looking_at(buf, &i, "Logging you in as \"*\"") ||
2383                  looking_at(buf, &i, "will be \"*\""))) {
2384               strcpy(ics_handle, star_match[0]);
2385               continue;
2386             }
2387
2388             if (loggedOn && !have_set_title && ics_handle[0] != NULLCHAR) {
2389               char buf[MSG_SIZ];
2390               snprintf(buf, sizeof(buf), "%s@%s", ics_handle, appData.icsHost);
2391               DisplayIcsInteractionTitle(buf);
2392               have_set_title = TRUE;
2393             }
2394
2395             /* skip finger notes */
2396             if (started == STARTED_NONE &&
2397                 ((buf[i] == ' ' && isdigit(buf[i+1])) ||
2398                  (buf[i] == '1' && buf[i+1] == '0')) &&
2399                 buf[i+2] == ':' && buf[i+3] == ' ') {
2400               started = STARTED_CHATTER;
2401               i += 3;
2402               continue;
2403             }
2404
2405             /* skip formula vars */
2406             if (started == STARTED_NONE &&
2407                 buf[i] == 'f' && isdigit(buf[i+1]) && buf[i+2] == ':') {
2408               started = STARTED_CHATTER;
2409               i += 3;
2410               continue;
2411             }
2412
2413             oldi = i;
2414             // [HGM] kibitz: try to recognize opponent engine-score kibitzes, to divert them to engine-output window
2415             if (appData.autoKibitz && started == STARTED_NONE &&
2416                 !appData.icsEngineAnalyze &&                     // [HGM] [DM] ICS analyze
2417                 (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack || gameMode == IcsObserving)) {
2418                 if(looking_at(buf, &i, "* kibitzes: ") &&
2419                    (StrStr(star_match[0], gameInfo.white) == star_match[0] ||
2420                     StrStr(star_match[0], gameInfo.black) == star_match[0]   )) { // kibitz of self or opponent
2421                         suppressKibitz = TRUE;
2422                         if((StrStr(star_match[0], gameInfo.white) == star_match[0]
2423                                 && (gameMode == IcsPlayingWhite)) ||
2424                            (StrStr(star_match[0], gameInfo.black) == star_match[0]
2425                                 && (gameMode == IcsPlayingBlack))   ) // opponent kibitz
2426                             started = STARTED_CHATTER; // own kibitz we simply discard
2427                         else {
2428                             started = STARTED_COMMENT; // make sure it will be collected in parse[]
2429                             parse_pos = 0; parse[0] = NULLCHAR;
2430                             savingComment = TRUE;
2431                             suppressKibitz = gameMode != IcsObserving ? 2 :
2432                                 (StrStr(star_match[0], gameInfo.white) == NULL) + 1;
2433                         }
2434                         continue;
2435                 } else
2436                 if(looking_at(buf, &i, "kibitzed to")) { // suppress the acknowledgements of our own autoKibitz
2437                     started = STARTED_CHATTER;
2438                     suppressKibitz = TRUE;
2439                 }
2440             } // [HGM] kibitz: end of patch
2441
2442 //if(appData.debugMode) fprintf(debugFP, "hunt for tell, buf = %s\n", buf+i);
2443
2444             // [HGM] chat: intercept tells by users for which we have an open chat window
2445             channel = -1;
2446             if(started == STARTED_NONE && (looking_at(buf, &i, "* tells you:") || looking_at(buf, &i, "* says:") ||
2447                                            looking_at(buf, &i, "* whispers:") ||
2448                                            looking_at(buf, &i, "*(*):") && (sscanf(star_match[1], "%d", &channel),1) ||
2449                                            looking_at(buf, &i, "*(*)(*):") && sscanf(star_match[2], "%d", &channel) == 1 )) {
2450                 int p;
2451                 sscanf(star_match[0], "%[^(]", talker+1); // strip (C) or (U) off ICS handle
2452                 chattingPartner = -1;
2453
2454                 if(channel >= 0) // channel broadcast; look if there is a chatbox for this channel
2455                 for(p=0; p<MAX_CHAT; p++) {
2456                     if(channel == atoi(chatPartner[p])) {
2457                     talker[0] = '['; strcat(talker, "]");
2458                     chattingPartner = p; break;
2459                     }
2460                 } else
2461                 if(buf[i-3] == 'r') // whisper; look if there is a WHISPER chatbox
2462                 for(p=0; p<MAX_CHAT; p++) {
2463                     if(!strcmp("WHISPER", chatPartner[p])) {
2464                         talker[0] = '['; strcat(talker, "]");
2465                         chattingPartner = p; break;
2466                     }
2467                 }
2468                 if(chattingPartner<0) // if not, look if there is a chatbox for this indivdual
2469                 for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
2470                     talker[0] = 0;
2471                     chattingPartner = p; break;
2472                 }
2473                 if(chattingPartner<0) i = oldi; else {
2474                     started = STARTED_COMMENT;
2475                     parse_pos = 0; parse[0] = NULLCHAR;
2476                     savingComment = TRUE;
2477                     suppressKibitz = TRUE;
2478                 }
2479             } // [HGM] chat: end of patch
2480
2481             if (appData.zippyTalk || appData.zippyPlay) {
2482                 /* [DM] Backup address for color zippy lines */
2483                 backup = i;
2484 #if ZIPPY
2485        #ifdef WIN32
2486                if (loggedOn == TRUE)
2487                        if (ZippyControl(buf, &backup) || ZippyConverse(buf, &backup) ||
2488                           (appData.zippyPlay && ZippyMatch(buf, &backup)));
2489        #else
2490                 if (ZippyControl(buf, &i) ||
2491                     ZippyConverse(buf, &i) ||
2492                     (appData.zippyPlay && ZippyMatch(buf, &i))) {
2493                       loggedOn = TRUE;
2494                       if (!appData.colorize) continue;
2495                 }
2496        #endif
2497 #endif
2498             } // [DM] 'else { ' deleted
2499                 if (
2500                     /* Regular tells and says */
2501                     (tkind = 1, looking_at(buf, &i, "* tells you: ")) ||
2502                     looking_at(buf, &i, "* (your partner) tells you: ") ||
2503                     looking_at(buf, &i, "* says: ") ||
2504                     /* Don't color "message" or "messages" output */
2505                     (tkind = 5, looking_at(buf, &i, "*. * (*:*): ")) ||
2506                     looking_at(buf, &i, "*. * at *:*: ") ||
2507                     looking_at(buf, &i, "--* (*:*): ") ||
2508                     /* Message notifications (same color as tells) */
2509                     looking_at(buf, &i, "* has left a message ") ||
2510                     looking_at(buf, &i, "* just sent you a message:\n") ||
2511                     /* Whispers and kibitzes */
2512                     (tkind = 2, looking_at(buf, &i, "* whispers: ")) ||
2513                     looking_at(buf, &i, "* kibitzes: ") ||
2514                     /* Channel tells */
2515                     (tkind = 3, looking_at(buf, &i, "*(*: "))) {
2516
2517                   if (tkind == 1 && strchr(star_match[0], ':')) {
2518                       /* Avoid "tells you:" spoofs in channels */
2519                      tkind = 3;
2520                   }
2521                   if (star_match[0][0] == NULLCHAR ||
2522                       strchr(star_match[0], ' ') ||
2523                       (tkind == 3 && strchr(star_match[1], ' '))) {
2524                     /* Reject bogus matches */
2525                     i = oldi;
2526                   } else {
2527                     if (appData.colorize) {
2528                       if (oldi > next_out) {
2529                         SendToPlayer(&buf[next_out], oldi - next_out);
2530                         next_out = oldi;
2531                       }
2532                       switch (tkind) {
2533                       case 1:
2534                         Colorize(ColorTell, FALSE);
2535                         curColor = ColorTell;
2536                         break;
2537                       case 2:
2538                         Colorize(ColorKibitz, FALSE);
2539                         curColor = ColorKibitz;
2540                         break;
2541                       case 3:
2542                         p = strrchr(star_match[1], '(');
2543                         if (p == NULL) {
2544                           p = star_match[1];
2545                         } else {
2546                           p++;
2547                         }
2548                         if (atoi(p) == 1) {
2549                           Colorize(ColorChannel1, FALSE);
2550                           curColor = ColorChannel1;
2551                         } else {
2552                           Colorize(ColorChannel, FALSE);
2553                           curColor = ColorChannel;
2554                         }
2555                         break;
2556                       case 5:
2557                         curColor = ColorNormal;
2558                         break;
2559                       }
2560                     }
2561                     if (started == STARTED_NONE && appData.autoComment &&
2562                         (gameMode == IcsObserving ||
2563                          gameMode == IcsPlayingWhite ||
2564                          gameMode == IcsPlayingBlack)) {
2565                       parse_pos = i - oldi;
2566                       memcpy(parse, &buf[oldi], parse_pos);
2567                       parse[parse_pos] = NULLCHAR;
2568                       started = STARTED_COMMENT;
2569                       savingComment = TRUE;
2570                     } else {
2571                       started = STARTED_CHATTER;
2572                       savingComment = FALSE;
2573                     }
2574                     loggedOn = TRUE;
2575                     continue;
2576                   }
2577                 }
2578
2579                 if (looking_at(buf, &i, "* s-shouts: ") ||
2580                     looking_at(buf, &i, "* c-shouts: ")) {
2581                     if (appData.colorize) {
2582                         if (oldi > next_out) {
2583                             SendToPlayer(&buf[next_out], oldi - next_out);
2584                             next_out = oldi;
2585                         }
2586                         Colorize(ColorSShout, FALSE);
2587                         curColor = ColorSShout;
2588                     }
2589                     loggedOn = TRUE;
2590                     started = STARTED_CHATTER;
2591                     continue;
2592                 }
2593
2594                 if (looking_at(buf, &i, "--->")) {
2595                     loggedOn = TRUE;
2596                     continue;
2597                 }
2598
2599                 if (looking_at(buf, &i, "* shouts: ") ||
2600                     looking_at(buf, &i, "--> ")) {
2601                     if (appData.colorize) {
2602                         if (oldi > next_out) {
2603                             SendToPlayer(&buf[next_out], oldi - next_out);
2604                             next_out = oldi;
2605                         }
2606                         Colorize(ColorShout, FALSE);
2607                         curColor = ColorShout;
2608                     }
2609                     loggedOn = TRUE;
2610                     started = STARTED_CHATTER;
2611                     continue;
2612                 }
2613
2614                 if (looking_at( buf, &i, "Challenge:")) {
2615                     if (appData.colorize) {
2616                         if (oldi > next_out) {
2617                             SendToPlayer(&buf[next_out], oldi - next_out);
2618                             next_out = oldi;
2619                         }
2620                         Colorize(ColorChallenge, FALSE);
2621                         curColor = ColorChallenge;
2622                     }
2623                     loggedOn = TRUE;
2624                     continue;
2625                 }
2626
2627                 if (looking_at(buf, &i, "* offers you") ||
2628                     looking_at(buf, &i, "* offers to be") ||
2629                     looking_at(buf, &i, "* would like to") ||
2630                     looking_at(buf, &i, "* requests to") ||
2631                     looking_at(buf, &i, "Your opponent offers") ||
2632                     looking_at(buf, &i, "Your opponent requests")) {
2633
2634                     if (appData.colorize) {
2635                         if (oldi > next_out) {
2636                             SendToPlayer(&buf[next_out], oldi - next_out);
2637                             next_out = oldi;
2638                         }
2639                         Colorize(ColorRequest, FALSE);
2640                         curColor = ColorRequest;
2641                     }
2642                     continue;
2643                 }
2644
2645                 if (looking_at(buf, &i, "* (*) seeking")) {
2646                     if (appData.colorize) {
2647                         if (oldi > next_out) {
2648                             SendToPlayer(&buf[next_out], oldi - next_out);
2649                             next_out = oldi;
2650                         }
2651                         Colorize(ColorSeek, FALSE);
2652                         curColor = ColorSeek;
2653                     }
2654                     continue;
2655             }
2656
2657             if (looking_at(buf, &i, "\\   ")) {
2658                 if (prevColor != ColorNormal) {
2659                     if (oldi > next_out) {
2660                         SendToPlayer(&buf[next_out], oldi - next_out);
2661                         next_out = oldi;
2662                     }
2663                     Colorize(prevColor, TRUE);
2664                     curColor = prevColor;
2665                 }
2666                 if (savingComment) {
2667                     parse_pos = i - oldi;
2668                     memcpy(parse, &buf[oldi], parse_pos);
2669                     parse[parse_pos] = NULLCHAR;
2670                     started = STARTED_COMMENT;
2671                 } else {
2672                     started = STARTED_CHATTER;
2673                 }
2674                 continue;
2675             }
2676
2677             if (looking_at(buf, &i, "Black Strength :") ||
2678                 looking_at(buf, &i, "<<< style 10 board >>>") ||
2679                 looking_at(buf, &i, "<10>") ||
2680                 looking_at(buf, &i, "#@#")) {
2681                 /* Wrong board style */
2682                 loggedOn = TRUE;
2683                 SendToICS(ics_prefix);
2684                 SendToICS("set style 12\n");
2685                 SendToICS(ics_prefix);
2686                 SendToICS("refresh\n");
2687                 continue;
2688             }
2689
2690             if (!have_sent_ICS_logon && looking_at(buf, &i, "login:")) {
2691                 ICSInitScript();
2692                 have_sent_ICS_logon = 1;
2693                 continue;
2694             }
2695
2696             if (ics_getting_history != H_GETTING_MOVES /*smpos kludge*/ &&
2697                 (looking_at(buf, &i, "\n<12> ") ||
2698                  looking_at(buf, &i, "<12> "))) {
2699                 loggedOn = TRUE;
2700                 if (oldi > next_out) {
2701                     SendToPlayer(&buf[next_out], oldi - next_out);
2702                 }
2703                 next_out = i;
2704                 started = STARTED_BOARD;
2705                 parse_pos = 0;
2706                 continue;
2707             }
2708
2709             if ((started == STARTED_NONE && looking_at(buf, &i, "\n<b1> ")) ||
2710                 looking_at(buf, &i, "<b1> ")) {
2711                 if (oldi > next_out) {
2712                     SendToPlayer(&buf[next_out], oldi - next_out);
2713                 }
2714                 next_out = i;
2715                 started = STARTED_HOLDINGS;
2716                 parse_pos = 0;
2717                 continue;
2718             }
2719
2720             if (looking_at(buf, &i, "* *vs. * *--- *")) {
2721                 loggedOn = TRUE;
2722                 /* Header for a move list -- first line */
2723
2724                 switch (ics_getting_history) {
2725                   case H_FALSE:
2726                     switch (gameMode) {
2727                       case IcsIdle:
2728                       case BeginningOfGame:
2729                         /* User typed "moves" or "oldmoves" while we
2730                            were idle.  Pretend we asked for these
2731                            moves and soak them up so user can step
2732                            through them and/or save them.
2733                            */
2734                         Reset(FALSE, TRUE);
2735                         gameMode = IcsObserving;
2736                         ModeHighlight();
2737                         ics_gamenum = -1;
2738                         ics_getting_history = H_GOT_UNREQ_HEADER;
2739                         break;
2740                       case EditGame: /*?*/
2741                       case EditPosition: /*?*/
2742                         /* Should above feature work in these modes too? */
2743                         /* For now it doesn't */
2744                         ics_getting_history = H_GOT_UNWANTED_HEADER;
2745                         break;
2746                       default:
2747                         ics_getting_history = H_GOT_UNWANTED_HEADER;
2748                         break;
2749                     }
2750                     break;
2751                   case H_REQUESTED:
2752                     /* Is this the right one? */
2753                     if (gameInfo.white && gameInfo.black &&
2754                         strcmp(gameInfo.white, star_match[0]) == 0 &&
2755                         strcmp(gameInfo.black, star_match[2]) == 0) {
2756                         /* All is well */
2757                         ics_getting_history = H_GOT_REQ_HEADER;
2758                     }
2759                     break;
2760                   case H_GOT_REQ_HEADER:
2761                   case H_GOT_UNREQ_HEADER:
2762                   case H_GOT_UNWANTED_HEADER:
2763                   case H_GETTING_MOVES:
2764                     /* Should not happen */
2765                     DisplayError(_("Error gathering move list: two headers"), 0);
2766                     ics_getting_history = H_FALSE;
2767                     break;
2768                 }
2769
2770                 /* Save player ratings into gameInfo if needed */
2771                 if ((ics_getting_history == H_GOT_REQ_HEADER ||
2772                      ics_getting_history == H_GOT_UNREQ_HEADER) &&
2773                     (gameInfo.whiteRating == -1 ||
2774                      gameInfo.blackRating == -1)) {
2775
2776                     gameInfo.whiteRating = string_to_rating(star_match[1]);
2777                     gameInfo.blackRating = string_to_rating(star_match[3]);
2778                     if (appData.debugMode)
2779                       fprintf(debugFP, _("Ratings from header: W %d, B %d\n"),
2780                               gameInfo.whiteRating, gameInfo.blackRating);
2781                 }
2782                 continue;
2783             }
2784
2785             if (looking_at(buf, &i,
2786               "* * match, initial time: * minute*, increment: * second")) {
2787                 /* Header for a move list -- second line */
2788                 /* Initial board will follow if this is a wild game */
2789                 if (gameInfo.event != NULL) free(gameInfo.event);
2790                 sprintf(str, "ICS %s %s match", star_match[0], star_match[1]);
2791                 gameInfo.event = StrSave(str);
2792                 /* [HGM] we switched variant. Translate boards if needed. */
2793                 VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event));
2794                 continue;
2795             }
2796
2797             if (looking_at(buf, &i, "Move  ")) {
2798                 /* Beginning of a move list */
2799                 switch (ics_getting_history) {
2800                   case H_FALSE:
2801                     /* Normally should not happen */
2802                     /* Maybe user hit reset while we were parsing */
2803                     break;
2804                   case H_REQUESTED:
2805                     /* Happens if we are ignoring a move list that is not
2806                      * the one we just requested.  Common if the user
2807                      * tries to observe two games without turning off
2808                      * getMoveList */
2809                     break;
2810                   case H_GETTING_MOVES:
2811                     /* Should not happen */
2812                     DisplayError(_("Error gathering move list: nested"), 0);
2813                     ics_getting_history = H_FALSE;
2814                     break;
2815                   case H_GOT_REQ_HEADER:
2816                     ics_getting_history = H_GETTING_MOVES;
2817                     started = STARTED_MOVES;
2818                     parse_pos = 0;
2819                     if (oldi > next_out) {
2820                         SendToPlayer(&buf[next_out], oldi - next_out);
2821                     }
2822                     break;
2823                   case H_GOT_UNREQ_HEADER:
2824                     ics_getting_history = H_GETTING_MOVES;
2825                     started = STARTED_MOVES_NOHIDE;
2826                     parse_pos = 0;
2827                     break;
2828                   case H_GOT_UNWANTED_HEADER:
2829                     ics_getting_history = H_FALSE;
2830                     break;
2831                 }
2832                 continue;
2833             }
2834
2835             if (looking_at(buf, &i, "% ") ||
2836                 ((started == STARTED_MOVES || started == STARTED_MOVES_NOHIDE)
2837                  && looking_at(buf, &i, "}*"))) { char *bookHit = NULL; // [HGM] book
2838                 savingComment = FALSE;
2839                 switch (started) {
2840                   case STARTED_MOVES:
2841                   case STARTED_MOVES_NOHIDE:
2842                     memcpy(&parse[parse_pos], &buf[oldi], i - oldi);
2843                     parse[parse_pos + i - oldi] = NULLCHAR;
2844                     ParseGameHistory(parse);
2845 #if ZIPPY
2846                     if (appData.zippyPlay && first.initDone) {
2847                         FeedMovesToProgram(&first, forwardMostMove);
2848                         if (gameMode == IcsPlayingWhite) {
2849                             if (WhiteOnMove(forwardMostMove)) {
2850                                 if (first.sendTime) {
2851                                   if (first.useColors) {
2852                                     SendToProgram("black\n", &first);
2853                                   }
2854                                   SendTimeRemaining(&first, TRUE);
2855                                 }
2856                                 if (first.useColors) {
2857                                   SendToProgram("white\n", &first); // [HGM] book: made sending of "go\n" book dependent
2858                                 }
2859                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: probe book for initial pos
2860                                 first.maybeThinking = TRUE;
2861                             } else {
2862                                 if (first.usePlayother) {
2863                                   if (first.sendTime) {
2864                                     SendTimeRemaining(&first, TRUE);
2865                                   }
2866                                   SendToProgram("playother\n", &first);
2867                                   firstMove = FALSE;
2868                                 } else {
2869                                   firstMove = TRUE;
2870                                 }
2871                             }
2872                         } else if (gameMode == IcsPlayingBlack) {
2873                             if (!WhiteOnMove(forwardMostMove)) {
2874                                 if (first.sendTime) {
2875                                   if (first.useColors) {
2876                                     SendToProgram("white\n", &first);
2877                                   }
2878                                   SendTimeRemaining(&first, FALSE);
2879                                 }
2880                                 if (first.useColors) {
2881                                   SendToProgram("black\n", &first);
2882                                 }
2883                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE);
2884                                 first.maybeThinking = TRUE;
2885                             } else {
2886                                 if (first.usePlayother) {
2887                                   if (first.sendTime) {
2888                                     SendTimeRemaining(&first, FALSE);
2889                                   }
2890                                   SendToProgram("playother\n", &first);
2891                                   firstMove = FALSE;
2892                                 } else {
2893                                   firstMove = TRUE;
2894                                 }
2895                             }
2896                         }
2897                     }
2898 #endif
2899                     if (gameMode == IcsObserving && ics_gamenum == -1) {
2900                         /* Moves came from oldmoves or moves command
2901                            while we weren't doing anything else.
2902                            */
2903                         currentMove = forwardMostMove;
2904                         ClearHighlights();/*!!could figure this out*/
2905                         flipView = appData.flipView;
2906                         DrawPosition(FALSE, boards[currentMove]);
2907                         DisplayBothClocks();
2908                         sprintf(str, "%s vs. %s",
2909                                 gameInfo.white, gameInfo.black);
2910                         DisplayTitle(str);
2911                         gameMode = IcsIdle;
2912                     } else {
2913                         /* Moves were history of an active game */
2914                         if (gameInfo.resultDetails != NULL) {
2915                             free(gameInfo.resultDetails);
2916                             gameInfo.resultDetails = NULL;
2917                         }
2918                     }
2919                     HistorySet(parseList, backwardMostMove,
2920                                forwardMostMove, currentMove-1);
2921                     DisplayMove(currentMove - 1);
2922                     if (started == STARTED_MOVES) next_out = i;
2923                     started = STARTED_NONE;
2924                     ics_getting_history = H_FALSE;
2925                     break;
2926
2927                   case STARTED_OBSERVE:
2928                     started = STARTED_NONE;
2929                     SendToICS(ics_prefix);
2930                     SendToICS("refresh\n");
2931                     break;
2932
2933                   default:
2934                     break;
2935                 }
2936                 if(bookHit) { // [HGM] book: simulate book reply
2937                     static char bookMove[MSG_SIZ]; // a bit generous?
2938
2939                     programStats.nodes = programStats.depth = programStats.time =
2940                     programStats.score = programStats.got_only_move = 0;
2941                     sprintf(programStats.movelist, "%s (xbook)", bookHit);
2942
2943                     strcpy(bookMove, "move ");
2944                     strcat(bookMove, bookHit);
2945                     HandleMachineMove(bookMove, &first);
2946                 }
2947                 continue;
2948             }
2949
2950             if ((started == STARTED_MOVES || started == STARTED_BOARD ||
2951                  started == STARTED_HOLDINGS ||
2952                  started == STARTED_MOVES_NOHIDE) && i >= leftover_len) {
2953                 /* Accumulate characters in move list or board */
2954                 parse[parse_pos++] = buf[i];
2955             }
2956
2957             /* Start of game messages.  Mostly we detect start of game
2958                when the first board image arrives.  On some versions
2959                of the ICS, though, we need to do a "refresh" after starting
2960                to observe in order to get the current board right away. */
2961             if (looking_at(buf, &i, "Adding game * to observation list")) {
2962                 started = STARTED_OBSERVE;
2963                 continue;
2964             }
2965
2966             /* Handle auto-observe */
2967             if (appData.autoObserve &&
2968                 (gameMode == IcsIdle || gameMode == BeginningOfGame) &&
2969                 looking_at(buf, &i, "Game notification: * (*) vs. * (*)")) {
2970                 char *player;
2971                 /* Choose the player that was highlighted, if any. */
2972                 if (star_match[0][0] == '\033' ||
2973                     star_match[1][0] != '\033') {
2974                     player = star_match[0];
2975                 } else {
2976                     player = star_match[2];
2977                 }
2978                 sprintf(str, "%sobserve %s\n",
2979                         ics_prefix, StripHighlightAndTitle(player));
2980                 SendToICS(str);
2981
2982                 /* Save ratings from notify string */
2983                 strcpy(player1Name, star_match[0]);
2984                 player1Rating = string_to_rating(star_match[1]);
2985                 strcpy(player2Name, star_match[2]);
2986                 player2Rating = string_to_rating(star_match[3]);
2987
2988                 if (appData.debugMode)
2989                   fprintf(debugFP,
2990                           "Ratings from 'Game notification:' %s %d, %s %d\n",
2991                           player1Name, player1Rating,
2992                           player2Name, player2Rating);
2993
2994                 continue;
2995             }
2996
2997             /* Deal with automatic examine mode after a game,
2998                and with IcsObserving -> IcsExamining transition */
2999             if (looking_at(buf, &i, "Entering examine mode for game *") ||
3000                 looking_at(buf, &i, "has made you an examiner of game *")) {
3001
3002                 int gamenum = atoi(star_match[0]);
3003                 if ((gameMode == IcsIdle || gameMode == IcsObserving) &&
3004                     gamenum == ics_gamenum) {
3005                     /* We were already playing or observing this game;
3006                        no need to refetch history */
3007                     gameMode = IcsExamining;
3008                     if (pausing) {
3009                         pauseExamForwardMostMove = forwardMostMove;
3010                     } else if (currentMove < forwardMostMove) {
3011                         ForwardInner(forwardMostMove);
3012                     }
3013                 } else {
3014                     /* I don't think this case really can happen */
3015                     SendToICS(ics_prefix);
3016                     SendToICS("refresh\n");
3017                 }
3018                 continue;
3019             }
3020
3021             /* Error messages */
3022 //          if (ics_user_moved) {
3023             if (1) { // [HGM] old way ignored error after move type in; ics_user_moved is not set then!
3024                 if (looking_at(buf, &i, "Illegal move") ||
3025                     looking_at(buf, &i, "Not a legal move") ||
3026                     looking_at(buf, &i, "Your king is in check") ||
3027                     looking_at(buf, &i, "It isn't your turn") ||
3028                     looking_at(buf, &i, "It is not your move")) {
3029                     /* Illegal move */
3030                     if (ics_user_moved && forwardMostMove > backwardMostMove) { // only backup if we already moved
3031                         currentMove = --forwardMostMove;
3032                         DisplayMove(currentMove - 1); /* before DMError */
3033                         DrawPosition(FALSE, boards[currentMove]);
3034                         SwitchClocks();
3035                         DisplayBothClocks();
3036                     }
3037                     DisplayMoveError(_("Illegal move (rejected by ICS)")); // [HGM] but always relay error msg
3038                     ics_user_moved = 0;
3039                     continue;
3040                 }
3041             }
3042
3043             if (looking_at(buf, &i, "still have time") ||
3044                 looking_at(buf, &i, "not out of time") ||
3045                 looking_at(buf, &i, "either player is out of time") ||
3046                 looking_at(buf, &i, "has timeseal; checking")) {
3047                 /* We must have called his flag a little too soon */
3048                 whiteFlag = blackFlag = FALSE;
3049                 continue;
3050             }
3051
3052             if (looking_at(buf, &i, "added * seconds to") ||
3053                 looking_at(buf, &i, "seconds were added to")) {
3054                 /* Update the clocks */
3055                 SendToICS(ics_prefix);
3056                 SendToICS("refresh\n");
3057                 continue;
3058             }
3059
3060             if (!ics_clock_paused && looking_at(buf, &i, "clock paused")) {
3061                 ics_clock_paused = TRUE;
3062                 StopClocks();
3063                 continue;
3064             }
3065
3066             if (ics_clock_paused && looking_at(buf, &i, "clock resumed")) {
3067                 ics_clock_paused = FALSE;
3068                 StartClocks();
3069                 continue;
3070             }
3071
3072             /* Grab player ratings from the Creating: message.
3073                Note we have to check for the special case when
3074                the ICS inserts things like [white] or [black]. */
3075             if (looking_at(buf, &i, "Creating: * (*)* * (*)") ||
3076                 looking_at(buf, &i, "Creating: * (*) [*] * (*)")) {
3077                 /* star_matches:
3078                    0    player 1 name (not necessarily white)
3079                    1    player 1 rating
3080                    2    empty, white, or black (IGNORED)
3081                    3    player 2 name (not necessarily black)
3082                    4    player 2 rating
3083
3084                    The names/ratings are sorted out when the game
3085                    actually starts (below).
3086                 */
3087                 strcpy(player1Name, StripHighlightAndTitle(star_match[0]));
3088                 player1Rating = string_to_rating(star_match[1]);
3089                 strcpy(player2Name, StripHighlightAndTitle(star_match[3]));
3090                 player2Rating = string_to_rating(star_match[4]);
3091
3092                 if (appData.debugMode)
3093                   fprintf(debugFP,
3094                           "Ratings from 'Creating:' %s %d, %s %d\n",
3095                           player1Name, player1Rating,
3096                           player2Name, player2Rating);
3097
3098                 continue;
3099             }
3100
3101             /* Improved generic start/end-of-game messages */
3102             if ((tkind=0, looking_at(buf, &i, "{Game * (* vs. *) *}*")) ||
3103                 (tkind=1, looking_at(buf, &i, "{Game * (*(*) vs. *(*)) *}*"))){
3104                 /* If tkind == 0: */
3105                 /* star_match[0] is the game number */
3106                 /*           [1] is the white player's name */
3107                 /*           [2] is the black player's name */
3108                 /* For end-of-game: */
3109                 /*           [3] is the reason for the game end */
3110                 /*           [4] is a PGN end game-token, preceded by " " */
3111                 /* For start-of-game: */
3112                 /*           [3] begins with "Creating" or "Continuing" */
3113                 /*           [4] is " *" or empty (don't care). */
3114                 int gamenum = atoi(star_match[0]);
3115                 char *whitename, *blackname, *why, *endtoken;
3116                 ChessMove endtype = (ChessMove) 0;
3117
3118                 if (tkind == 0) {
3119                   whitename = star_match[1];
3120                   blackname = star_match[2];
3121                   why = star_match[3];
3122                   endtoken = star_match[4];
3123                 } else {
3124                   whitename = star_match[1];
3125                   blackname = star_match[3];
3126                   why = star_match[5];
3127                   endtoken = star_match[6];
3128                 }
3129
3130                 /* Game start messages */
3131                 if (strncmp(why, "Creating ", 9) == 0 ||
3132                     strncmp(why, "Continuing ", 11) == 0) {
3133                     gs_gamenum = gamenum;
3134                     strcpy(gs_kind, strchr(why, ' ') + 1);
3135 #if ZIPPY
3136                     if (appData.zippyPlay) {
3137                         ZippyGameStart(whitename, blackname);
3138                     }
3139 #endif /*ZIPPY*/
3140                     continue;
3141                 }
3142
3143                 /* Game end messages */
3144                 if (gameMode == IcsIdle || gameMode == BeginningOfGame ||
3145                     ics_gamenum != gamenum) {
3146                     continue;
3147                 }
3148                 while (endtoken[0] == ' ') endtoken++;
3149                 switch (endtoken[0]) {
3150                   case '*':
3151                   default:
3152                     endtype = GameUnfinished;
3153                     break;
3154                   case '0':
3155                     endtype = BlackWins;
3156                     break;
3157                   case '1':
3158                     if (endtoken[1] == '/')
3159                       endtype = GameIsDrawn;
3160                     else
3161                       endtype = WhiteWins;
3162                     break;
3163                 }
3164                 GameEnds(endtype, why, GE_ICS);
3165 #if ZIPPY
3166                 if (appData.zippyPlay && first.initDone) {
3167                     ZippyGameEnd(endtype, why);
3168                     if (first.pr == NULL) {
3169                       /* Start the next process early so that we'll
3170                          be ready for the next challenge */
3171                       StartChessProgram(&first);
3172                     }
3173                     /* Send "new" early, in case this command takes
3174                        a long time to finish, so that we'll be ready
3175                        for the next challenge. */
3176                     gameInfo.variant = VariantNormal; // [HGM] variantswitch: suppress sending of 'variant'
3177                     Reset(TRUE, TRUE);
3178                 }
3179 #endif /*ZIPPY*/
3180                 continue;
3181             }
3182
3183             if (looking_at(buf, &i, "Removing game * from observation") ||
3184                 looking_at(buf, &i, "no longer observing game *") ||
3185                 looking_at(buf, &i, "Game * (*) has no examiners")) {
3186                 if (gameMode == IcsObserving &&
3187                     atoi(star_match[0]) == ics_gamenum)
3188                   {
3189                       /* icsEngineAnalyze */
3190                       if (appData.icsEngineAnalyze) {
3191                             ExitAnalyzeMode();
3192                             ModeHighlight();
3193                       }
3194                       StopClocks();
3195                       gameMode = IcsIdle;
3196                       ics_gamenum = -1;
3197                       ics_user_moved = FALSE;
3198                   }
3199                 continue;
3200             }
3201
3202             if (looking_at(buf, &i, "no longer examining game *")) {
3203                 if (gameMode == IcsExamining &&
3204                     atoi(star_match[0]) == ics_gamenum)
3205                   {
3206                       gameMode = IcsIdle;
3207                       ics_gamenum = -1;
3208                       ics_user_moved = FALSE;
3209                   }
3210                 continue;
3211             }
3212
3213             /* Advance leftover_start past any newlines we find,
3214                so only partial lines can get reparsed */
3215             if (looking_at(buf, &i, "\n")) {
3216                 prevColor = curColor;
3217                 if (curColor != ColorNormal) {
3218                     if (oldi > next_out) {
3219                         SendToPlayer(&buf[next_out], oldi - next_out);
3220                         next_out = oldi;
3221                     }
3222                     Colorize(ColorNormal, FALSE);
3223                     curColor = ColorNormal;
3224                 }
3225                 if (started == STARTED_BOARD) {
3226                     started = STARTED_NONE;
3227                     parse[parse_pos] = NULLCHAR;
3228                     ParseBoard12(parse);
3229                     ics_user_moved = 0;
3230
3231                     /* Send premove here */
3232                     if (appData.premove) {
3233                       char str[MSG_SIZ];
3234                       if (currentMove == 0 &&
3235                           gameMode == IcsPlayingWhite &&
3236                           appData.premoveWhite) {
3237                         sprintf(str, "%s%s\n", ics_prefix,
3238                                 appData.premoveWhiteText);
3239                         if (appData.debugMode)
3240                           fprintf(debugFP, "Sending premove:\n");
3241                         SendToICS(str);
3242                       } else if (currentMove == 1 &&
3243                                  gameMode == IcsPlayingBlack &&
3244                                  appData.premoveBlack) {
3245                         sprintf(str, "%s%s\n", ics_prefix,
3246                                 appData.premoveBlackText);
3247                         if (appData.debugMode)
3248                           fprintf(debugFP, "Sending premove:\n");
3249                         SendToICS(str);
3250                       } else if (gotPremove) {
3251                         gotPremove = 0;
3252                         ClearPremoveHighlights();
3253                         if (appData.debugMode)
3254                           fprintf(debugFP, "Sending premove:\n");
3255                           UserMoveEvent(premoveFromX, premoveFromY,
3256                                         premoveToX, premoveToY,
3257                                         premovePromoChar);
3258                       }
3259                     }
3260
3261                     /* Usually suppress following prompt */
3262                     if (!(forwardMostMove == 0 && gameMode == IcsExamining)) {
3263                         if (looking_at(buf, &i, "*% ")) {
3264                             savingComment = FALSE;
3265                         }
3266                     }
3267                     next_out = i;
3268                 } else if (started == STARTED_HOLDINGS) {
3269                     int gamenum;
3270                     char new_piece[MSG_SIZ];
3271                     started = STARTED_NONE;
3272                     parse[parse_pos] = NULLCHAR;
3273                     if (appData.debugMode)
3274                       fprintf(debugFP, "Parsing holdings: %s, currentMove = %d\n",
3275                                                         parse, currentMove);
3276                     if (sscanf(parse, " game %d", &gamenum) == 1 &&
3277                         gamenum == ics_gamenum) {
3278                         if (gameInfo.variant == VariantNormal) {
3279                           /* [HGM] We seem to switch variant during a game!
3280                            * Presumably no holdings were displayed, so we have
3281                            * to move the position two files to the right to
3282                            * create room for them!
3283                            */
3284                           VariantSwitch(boards[currentMove], VariantCrazyhouse); /* temp guess */
3285                           /* Get a move list just to see the header, which
3286                              will tell us whether this is really bug or zh */
3287                           if (ics_getting_history == H_FALSE) {
3288                             ics_getting_history = H_REQUESTED;
3289                             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3290                             SendToICS(str);
3291                           }
3292                         }
3293                         new_piece[0] = NULLCHAR;
3294                         sscanf(parse, "game %d white [%s black [%s <- %s",
3295                                &gamenum, white_holding, black_holding,
3296                                new_piece);
3297                         white_holding[strlen(white_holding)-1] = NULLCHAR;
3298                         black_holding[strlen(black_holding)-1] = NULLCHAR;
3299                         /* [HGM] copy holdings to board holdings area */
3300                         CopyHoldings(boards[currentMove], white_holding, WhitePawn);
3301                         CopyHoldings(boards[currentMove], black_holding, BlackPawn);
3302 #if ZIPPY
3303                         if (appData.zippyPlay && first.initDone) {
3304                             ZippyHoldings(white_holding, black_holding,
3305                                           new_piece);
3306                         }
3307 #endif /*ZIPPY*/
3308                         if (tinyLayout || smallLayout) {
3309                             char wh[16], bh[16];
3310                             PackHolding(wh, white_holding);
3311                             PackHolding(bh, black_holding);
3312                             sprintf(str, "[%s-%s] %s-%s", wh, bh,
3313                                     gameInfo.white, gameInfo.black);
3314                         } else {
3315                             sprintf(str, "%s [%s] vs. %s [%s]",
3316                                     gameInfo.white, white_holding,
3317                                     gameInfo.black, black_holding);
3318                         }
3319
3320                         DrawPosition(FALSE, boards[currentMove]);
3321                         DisplayTitle(str);
3322                     }
3323                     /* Suppress following prompt */
3324                     if (looking_at(buf, &i, "*% ")) {
3325                         savingComment = FALSE;
3326                     }
3327                     next_out = i;
3328                 }
3329                 continue;
3330             }
3331
3332             i++;                /* skip unparsed character and loop back */
3333         }
3334
3335         if (started != STARTED_MOVES && started != STARTED_BOARD && !suppressKibitz && // [HGM] kibitz suppress printing in ICS interaction window
3336             started != STARTED_HOLDINGS && i > next_out) {
3337             SendToPlayer(&buf[next_out], i - next_out);
3338             next_out = i;
3339         }
3340         suppressKibitz = FALSE; // [HGM] kibitz: has done its duty in if-statement above
3341
3342         leftover_len = buf_len - leftover_start;
3343         /* if buffer ends with something we couldn't parse,
3344            reparse it after appending the next read */
3345
3346     } else if (count == 0) {
3347         RemoveInputSource(isr);
3348         DisplayFatalError(_("Connection closed by ICS"), 0, 0);
3349     } else {
3350         DisplayFatalError(_("Error reading from ICS"), error, 1);
3351     }
3352 }
3353
3354
3355 /* Board style 12 looks like this:
3356
3357    <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
3358
3359  * The "<12> " is stripped before it gets to this routine.  The two
3360  * trailing 0's (flip state and clock ticking) are later addition, and
3361  * some chess servers may not have them, or may have only the first.
3362  * Additional trailing fields may be added in the future.
3363  */
3364
3365 #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"
3366
3367 #define RELATION_OBSERVING_PLAYED    0
3368 #define RELATION_OBSERVING_STATIC   -2   /* examined, oldmoves, or smoves */
3369 #define RELATION_PLAYING_MYMOVE      1
3370 #define RELATION_PLAYING_NOTMYMOVE  -1
3371 #define RELATION_EXAMINING           2
3372 #define RELATION_ISOLATED_BOARD     -3
3373 #define RELATION_STARTING_POSITION  -4   /* FICS only */
3374
3375 void
3376 ParseBoard12(string)
3377      char *string;
3378 {
3379     GameMode newGameMode;
3380     int gamenum, newGame, newMove, relation, basetime, increment, ics_flip = 0, i;
3381     int j, k, n, moveNum, white_stren, black_stren, white_time, black_time, takeback;
3382     int double_push, castle_ws, castle_wl, castle_bs, castle_bl, irrev_count;
3383     char to_play, board_chars[200];
3384     char move_str[500], str[500], elapsed_time[500];
3385     char black[32], white[32];
3386     Board board;
3387     int prevMove = currentMove;
3388     int ticking = 2;
3389     ChessMove moveType;
3390     int fromX, fromY, toX, toY;
3391     char promoChar;
3392     int ranks=1, files=0; /* [HGM] ICS80: allow variable board size */
3393     char *bookHit = NULL; // [HGM] book
3394
3395     fromX = fromY = toX = toY = -1;
3396
3397     newGame = FALSE;
3398
3399     if (appData.debugMode)
3400       fprintf(debugFP, _("Parsing board: %s\n"), string);
3401
3402     move_str[0] = NULLCHAR;
3403     elapsed_time[0] = NULLCHAR;
3404     {   /* [HGM] figure out how many ranks and files the board has, for ICS extension used by Capablanca server */
3405         int  i = 0, j;
3406         while(i < 199 && (string[i] != ' ' || string[i+2] != ' ')) {
3407             if(string[i] == ' ') { ranks++; files = 0; }
3408             else files++;
3409             i++;
3410         }
3411         for(j = 0; j <i; j++) board_chars[j] = string[j];
3412         board_chars[i] = '\0';
3413         string += i + 1;
3414     }
3415     n = sscanf(string, PATTERN, &to_play, &double_push,
3416                &castle_ws, &castle_wl, &castle_bs, &castle_bl, &irrev_count,
3417                &gamenum, white, black, &relation, &basetime, &increment,
3418                &white_stren, &black_stren, &white_time, &black_time,
3419                &moveNum, str, elapsed_time, move_str, &ics_flip,
3420                &ticking);
3421
3422     if (n < 21) {
3423         snprintf(str, sizeof(str), _("Failed to parse board string:\n\"%s\""), string);
3424         DisplayError(str, 0);
3425         return;
3426     }
3427
3428     /* Convert the move number to internal form */
3429     moveNum = (moveNum - 1) * 2;
3430     if (to_play == 'B') moveNum++;
3431     if (moveNum >= MAX_MOVES) {
3432       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
3433                         0, 1);
3434       return;
3435     }
3436
3437     switch (relation) {
3438       case RELATION_OBSERVING_PLAYED:
3439       case RELATION_OBSERVING_STATIC:
3440         if (gamenum == -1) {
3441             /* Old ICC buglet */
3442             relation = RELATION_OBSERVING_STATIC;
3443         }
3444         newGameMode = IcsObserving;
3445         break;
3446       case RELATION_PLAYING_MYMOVE:
3447       case RELATION_PLAYING_NOTMYMOVE:
3448         newGameMode =
3449           ((relation == RELATION_PLAYING_MYMOVE) == (to_play == 'W')) ?
3450             IcsPlayingWhite : IcsPlayingBlack;
3451         break;
3452       case RELATION_EXAMINING:
3453         newGameMode = IcsExamining;
3454         break;
3455       case RELATION_ISOLATED_BOARD:
3456       default:
3457         /* Just display this board.  If user was doing something else,
3458            we will forget about it until the next board comes. */
3459         newGameMode = IcsIdle;
3460         break;
3461       case RELATION_STARTING_POSITION:
3462         newGameMode = gameMode;
3463         break;
3464     }
3465
3466     /* Modify behavior for initial board display on move listing
3467        of wild games.
3468        */
3469     switch (ics_getting_history) {
3470       case H_FALSE:
3471       case H_REQUESTED:
3472         break;
3473       case H_GOT_REQ_HEADER:
3474       case H_GOT_UNREQ_HEADER:
3475         /* This is the initial position of the current game */
3476         gamenum = ics_gamenum;
3477         moveNum = 0;            /* old ICS bug workaround */
3478         if (to_play == 'B') {
3479           startedFromSetupPosition = TRUE;
3480           blackPlaysFirst = TRUE;
3481           moveNum = 1;
3482           if (forwardMostMove == 0) forwardMostMove = 1;
3483           if (backwardMostMove == 0) backwardMostMove = 1;
3484           if (currentMove == 0) currentMove = 1;
3485         }
3486         newGameMode = gameMode;
3487         relation = RELATION_STARTING_POSITION; /* ICC needs this */
3488         break;
3489       case H_GOT_UNWANTED_HEADER:
3490         /* This is an initial board that we don't want */
3491         return;
3492       case H_GETTING_MOVES:
3493         /* Should not happen */
3494         DisplayError(_("Error gathering move list: extra board"), 0);
3495         ics_getting_history = H_FALSE;
3496         return;
3497     }
3498
3499     /* Take action if this is the first board of a new game, or of a
3500        different game than is currently being displayed.  */
3501     if (gamenum != ics_gamenum || newGameMode != gameMode ||
3502         relation == RELATION_ISOLATED_BOARD) {
3503
3504         /* Forget the old game and get the history (if any) of the new one */
3505         if (gameMode != BeginningOfGame) {
3506           Reset(FALSE, TRUE);
3507         }
3508         newGame = TRUE;
3509         if (appData.autoRaiseBoard) BoardToTop();
3510         prevMove = -3;
3511         if (gamenum == -1) {
3512             newGameMode = IcsIdle;
3513         } else if (moveNum > 0 && newGameMode != IcsIdle &&
3514                    appData.getMoveList) {
3515             /* Need to get game history */
3516             ics_getting_history = H_REQUESTED;
3517             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3518             SendToICS(str);
3519         }
3520
3521         /* Initially flip the board to have black on the bottom if playing
3522            black or if the ICS flip flag is set, but let the user change
3523            it with the Flip View button. */
3524         flipView = appData.autoFlipView ?
3525           (newGameMode == IcsPlayingBlack) || ics_flip :
3526           appData.flipView;
3527
3528         /* Done with values from previous mode; copy in new ones */
3529         gameMode = newGameMode;
3530         ModeHighlight();
3531         ics_gamenum = gamenum;
3532         if (gamenum == gs_gamenum) {
3533             int klen = strlen(gs_kind);
3534             if (gs_kind[klen - 1] == '.') gs_kind[klen - 1] = NULLCHAR;
3535             sprintf(str, "ICS %s", gs_kind);
3536             gameInfo.event = StrSave(str);
3537         } else {
3538             gameInfo.event = StrSave("ICS game");
3539         }
3540         gameInfo.site = StrSave(appData.icsHost);
3541         gameInfo.date = PGNDate();
3542         gameInfo.round = StrSave("-");
3543         gameInfo.white = StrSave(white);
3544         gameInfo.black = StrSave(black);
3545         timeControl = basetime * 60 * 1000;
3546         timeControl_2 = 0;
3547         timeIncrement = increment * 1000;
3548         movesPerSession = 0;
3549         gameInfo.timeControl = TimeControlTagValue();
3550         VariantSwitch(board, StringToVariant(gameInfo.event) );
3551   if (appData.debugMode) {
3552     fprintf(debugFP, "ParseBoard says variant = '%s'\n", gameInfo.event);
3553     fprintf(debugFP, "recognized as %s\n", VariantName(gameInfo.variant));
3554     setbuf(debugFP, NULL);
3555   }
3556
3557         gameInfo.outOfBook = NULL;
3558
3559         /* Do we have the ratings? */
3560         if (strcmp(player1Name, white) == 0 &&
3561             strcmp(player2Name, black) == 0) {
3562             if (appData.debugMode)
3563               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
3564                       player1Rating, player2Rating);
3565             gameInfo.whiteRating = player1Rating;
3566             gameInfo.blackRating = player2Rating;
3567         } else if (strcmp(player2Name, white) == 0 &&
3568                    strcmp(player1Name, black) == 0) {
3569             if (appData.debugMode)
3570               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
3571                       player2Rating, player1Rating);
3572             gameInfo.whiteRating = player2Rating;
3573             gameInfo.blackRating = player1Rating;
3574         }
3575         player1Name[0] = player2Name[0] = NULLCHAR;
3576
3577         /* Silence shouts if requested */
3578         if (appData.quietPlay &&
3579             (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)) {
3580             SendToICS(ics_prefix);
3581             SendToICS("set shout 0\n");
3582         }
3583     }
3584
3585     /* Deal with midgame name changes */
3586     if (!newGame) {
3587         if (!gameInfo.white || strcmp(gameInfo.white, white) != 0) {
3588             if (gameInfo.white) free(gameInfo.white);
3589             gameInfo.white = StrSave(white);
3590         }
3591         if (!gameInfo.black || strcmp(gameInfo.black, black) != 0) {
3592             if (gameInfo.black) free(gameInfo.black);
3593             gameInfo.black = StrSave(black);
3594         }
3595     }
3596
3597     /* Throw away game result if anything actually changes in examine mode */
3598     if (gameMode == IcsExamining && !newGame) {
3599         gameInfo.result = GameUnfinished;
3600         if (gameInfo.resultDetails != NULL) {
3601             free(gameInfo.resultDetails);
3602             gameInfo.resultDetails = NULL;
3603         }
3604     }
3605
3606     /* In pausing && IcsExamining mode, we ignore boards coming
3607        in if they are in a different variation than we are. */
3608     if (pauseExamInvalid) return;
3609     if (pausing && gameMode == IcsExamining) {
3610         if (moveNum <= pauseExamForwardMostMove) {
3611             pauseExamInvalid = TRUE;
3612             forwardMostMove = pauseExamForwardMostMove;
3613             return;
3614         }
3615     }
3616
3617   if (appData.debugMode) {
3618     fprintf(debugFP, "load %dx%d board\n", files, ranks);
3619   }
3620     /* Parse the board */
3621     for (k = 0; k < ranks; k++) {
3622       for (j = 0; j < files; j++)
3623         board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
3624       if(gameInfo.holdingsWidth > 1) {
3625            board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
3626            board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
3627       }
3628     }
3629     CopyBoard(boards[moveNum], board);
3630     if (moveNum == 0) {
3631         startedFromSetupPosition =
3632           !CompareBoards(board, initialPosition);
3633         if(startedFromSetupPosition)
3634             initialRulePlies = irrev_count; /* [HGM] 50-move counter offset */
3635     }
3636
3637     /* [HGM] Set castling rights. Take the outermost Rooks,
3638        to make it also work for FRC opening positions. Note that board12
3639        is really defective for later FRC positions, as it has no way to
3640        indicate which Rook can castle if they are on the same side of King.
3641        For the initial position we grant rights to the outermost Rooks,
3642        and remember thos rights, and we then copy them on positions
3643        later in an FRC game. This means WB might not recognize castlings with
3644        Rooks that have moved back to their original position as illegal,
3645        but in ICS mode that is not its job anyway.
3646     */
3647     if(moveNum == 0 || gameInfo.variant != VariantFischeRandom)
3648     { int i, j; ChessSquare wKing = WhiteKing, bKing = BlackKing;
3649
3650         for(i=BOARD_LEFT, j= -1; i<BOARD_RGHT; i++)
3651             if(board[0][i] == WhiteRook) j = i;
3652         initialRights[0] = castlingRights[moveNum][0] = (castle_ws == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3653         for(i=BOARD_RGHT-1, j= -1; i>=BOARD_LEFT; i--)
3654             if(board[0][i] == WhiteRook) j = i;
3655         initialRights[1] = castlingRights[moveNum][1] = (castle_wl == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3656         for(i=BOARD_LEFT, j= -1; i<BOARD_RGHT; i++)
3657             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
3658         initialRights[3] = castlingRights[moveNum][3] = (castle_bs == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3659         for(i=BOARD_RGHT-1, j= -1; i>=BOARD_LEFT; i--)
3660             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
3661         initialRights[4] = castlingRights[moveNum][4] = (castle_bl == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3662
3663         if(gameInfo.variant == VariantKnightmate) { wKing = WhiteUnicorn; bKing = BlackUnicorn; }
3664         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
3665             if(board[0][k] == wKing) initialRights[2] = castlingRights[moveNum][2] = k;
3666         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
3667             if(board[BOARD_HEIGHT-1][k] == bKing)
3668                 initialRights[5] = castlingRights[moveNum][5] = k;
3669     } else { int r;
3670         r = castlingRights[moveNum][0] = initialRights[0];
3671         if(board[0][r] != WhiteRook) castlingRights[moveNum][0] = -1;
3672         r = castlingRights[moveNum][1] = initialRights[1];
3673         if(board[0][r] != WhiteRook) castlingRights[moveNum][1] = -1;
3674         r = castlingRights[moveNum][3] = initialRights[3];
3675         if(board[BOARD_HEIGHT-1][r] != BlackRook) castlingRights[moveNum][3] = -1;
3676         r = castlingRights[moveNum][4] = initialRights[4];
3677         if(board[BOARD_HEIGHT-1][r] != BlackRook) castlingRights[moveNum][4] = -1;
3678         /* wildcastle kludge: always assume King has rights */
3679         r = castlingRights[moveNum][2] = initialRights[2];
3680         r = castlingRights[moveNum][5] = initialRights[5];
3681     }
3682     /* [HGM] e.p. rights. Assume that ICS sends file number here? */
3683     epStatus[moveNum] = double_push == -1 ? EP_NONE : double_push + BOARD_LEFT;
3684
3685
3686     if (ics_getting_history == H_GOT_REQ_HEADER ||
3687         ics_getting_history == H_GOT_UNREQ_HEADER) {
3688         /* This was an initial position from a move list, not
3689            the current position */
3690         return;
3691     }
3692
3693     /* Update currentMove and known move number limits */
3694     newMove = newGame || moveNum > forwardMostMove;
3695
3696     /* [DM] If we found takebacks during icsEngineAnalyze try send to engine */
3697     if (!newGame && appData.icsEngineAnalyze && moveNum < forwardMostMove) {
3698         takeback = forwardMostMove - moveNum;
3699         for (i = 0; i < takeback; i++) {
3700              if (appData.debugMode) fprintf(debugFP, "take back move\n");
3701              SendToProgram("undo\n", &first);
3702         }
3703     }
3704
3705     if (newGame) {
3706         forwardMostMove = backwardMostMove = currentMove = moveNum;
3707         if (gameMode == IcsExamining && moveNum == 0) {
3708           /* Workaround for ICS limitation: we are not told the wild
3709              type when starting to examine a game.  But if we ask for
3710              the move list, the move list header will tell us */
3711             ics_getting_history = H_REQUESTED;
3712             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3713             SendToICS(str);
3714         }
3715     } else if (moveNum == forwardMostMove + 1 || moveNum == forwardMostMove
3716                || (moveNum < forwardMostMove && moveNum >= backwardMostMove)) {
3717         forwardMostMove = moveNum;
3718         if (!pausing || currentMove > forwardMostMove)
3719           currentMove = forwardMostMove;
3720     } else {
3721         /* New part of history that is not contiguous with old part */
3722         if (pausing && gameMode == IcsExamining) {
3723             pauseExamInvalid = TRUE;
3724             forwardMostMove = pauseExamForwardMostMove;
3725             return;
3726         }
3727         forwardMostMove = backwardMostMove = currentMove = moveNum;
3728         if (gameMode == IcsExamining && moveNum > 0 && appData.getMoveList) {
3729             ics_getting_history = H_REQUESTED;
3730             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3731             SendToICS(str);
3732         }
3733     }
3734
3735     /* Update the clocks */
3736     if (strchr(elapsed_time, '.')) {
3737       /* Time is in ms */
3738       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time;
3739       timeRemaining[1][moveNum] = blackTimeRemaining = black_time;
3740     } else {
3741       /* Time is in seconds */
3742       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time * 1000;
3743       timeRemaining[1][moveNum] = blackTimeRemaining = black_time * 1000;
3744     }
3745
3746
3747 #if ZIPPY
3748     if (appData.zippyPlay && newGame &&
3749         gameMode != IcsObserving && gameMode != IcsIdle &&
3750         gameMode != IcsExamining)
3751       ZippyFirstBoard(moveNum, basetime, increment);
3752 #endif
3753
3754     /* Put the move on the move list, first converting
3755        to canonical algebraic form. */
3756     if (moveNum > 0) {
3757   if (appData.debugMode) {
3758     if (appData.debugMode) { int f = forwardMostMove;
3759         fprintf(debugFP, "parseboard %d, castling = %d %d %d %d %d %d\n", f,
3760                 castlingRights[f][0],castlingRights[f][1],castlingRights[f][2],castlingRights[f][3],castlingRights[f][4],castlingRights[f][5]);
3761     }
3762     fprintf(debugFP, "accepted move %s from ICS, parse it.\n", move_str);
3763     fprintf(debugFP, "moveNum = %d\n", moveNum);
3764     fprintf(debugFP, "board = %d-%d x %d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT);
3765     setbuf(debugFP, NULL);
3766   }
3767         if (moveNum <= backwardMostMove) {
3768             /* We don't know what the board looked like before
3769                this move.  Punt. */
3770             strcpy(parseList[moveNum - 1], move_str);
3771             strcat(parseList[moveNum - 1], " ");
3772             strcat(parseList[moveNum - 1], elapsed_time);
3773             moveList[moveNum - 1][0] = NULLCHAR;
3774         } else if (strcmp(move_str, "none") == 0) {
3775             // [HGM] long SAN: swapped order; test for 'none' before parsing move
3776             /* Again, we don't know what the board looked like;
3777                this is really the start of the game. */
3778             parseList[moveNum - 1][0] = NULLCHAR;
3779             moveList[moveNum - 1][0] = NULLCHAR;
3780             backwardMostMove = moveNum;
3781             startedFromSetupPosition = TRUE;
3782             fromX = fromY = toX = toY = -1;
3783         } else {
3784           // [HGM] long SAN: if legality-testing is off, disambiguation might not work or give wrong move.
3785           //                 So we parse the long-algebraic move string in stead of the SAN move
3786           int valid; char buf[MSG_SIZ], *prom;
3787
3788           // str looks something like "Q/a1-a2"; kill the slash
3789           if(str[1] == '/')
3790                 sprintf(buf, "%c%s", str[0], str+2);
3791           else  strcpy(buf, str); // might be castling
3792           if((prom = strstr(move_str, "=")) && !strstr(buf, "="))
3793                 strcat(buf, prom); // long move lacks promo specification!
3794           if(!appData.testLegality && move_str[1] != '@') { // drops never ambiguous (parser chokes on long form!)
3795                 if(appData.debugMode)
3796                         fprintf(debugFP, "replaced ICS move '%s' by '%s'\n", move_str, buf);
3797                 strcpy(move_str, buf);
3798           }
3799           valid = ParseOneMove(move_str, moveNum - 1, &moveType,
3800                                 &fromX, &fromY, &toX, &toY, &promoChar)
3801                || ParseOneMove(buf, moveNum - 1, &moveType,
3802                                 &fromX, &fromY, &toX, &toY, &promoChar);
3803           // end of long SAN patch
3804           if (valid) {
3805             (void) CoordsToAlgebraic(boards[moveNum - 1],
3806                                      PosFlags(moveNum - 1), EP_UNKNOWN,
3807                                      fromY, fromX, toY, toX, promoChar,
3808                                      parseList[moveNum-1]);
3809             switch (MateTest(boards[moveNum], PosFlags(moveNum), EP_UNKNOWN,
3810                              castlingRights[moveNum]) ) {
3811               case MT_NONE:
3812               case MT_STALEMATE:
3813               default:
3814                 break;
3815               case MT_CHECK:
3816                 if(gameInfo.variant != VariantShogi)
3817                     strcat(parseList[moveNum - 1], "+");
3818                 break;
3819               case MT_CHECKMATE:
3820               case MT_STAINMATE: // [HGM] xq: for notation stalemate that wins counts as checkmate
3821                 strcat(parseList[moveNum - 1], "#");
3822                 break;
3823             }
3824             strcat(parseList[moveNum - 1], " ");
3825             strcat(parseList[moveNum - 1], elapsed_time);
3826             /* currentMoveString is set as a side-effect of ParseOneMove */
3827             strcpy(moveList[moveNum - 1], currentMoveString);
3828             strcat(moveList[moveNum - 1], "\n");
3829           } else {
3830             /* Move from ICS was illegal!?  Punt. */
3831   if (appData.debugMode) {
3832     fprintf(debugFP, "Illegal move from ICS '%s'\n", move_str);
3833     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
3834   }
3835             strcpy(parseList[moveNum - 1], move_str);
3836             strcat(parseList[moveNum - 1], " ");
3837             strcat(parseList[moveNum - 1], elapsed_time);
3838             moveList[moveNum - 1][0] = NULLCHAR;
3839             fromX = fromY = toX = toY = -1;
3840           }
3841         }
3842   if (appData.debugMode) {
3843     fprintf(debugFP, "Move parsed to '%s'\n", parseList[moveNum - 1]);
3844     setbuf(debugFP, NULL);
3845   }
3846
3847 #if ZIPPY
3848         /* Send move to chess program (BEFORE animating it). */
3849         if (appData.zippyPlay && !newGame && newMove &&
3850            (!appData.getMoveList || backwardMostMove == 0) && first.initDone) {
3851
3852             if ((gameMode == IcsPlayingWhite && WhiteOnMove(moveNum)) ||
3853                 (gameMode == IcsPlayingBlack && !WhiteOnMove(moveNum))) {
3854                 if (moveList[moveNum - 1][0] == NULLCHAR) {
3855                     sprintf(str, _("Couldn't parse move \"%s\" from ICS"),
3856                             move_str);
3857                     DisplayError(str, 0);
3858                 } else {
3859                     if (first.sendTime) {
3860                         SendTimeRemaining(&first, gameMode == IcsPlayingWhite);
3861                     }
3862                     bookHit = SendMoveToBookUser(moveNum - 1, &first, FALSE); // [HGM] book
3863                     if (firstMove && !bookHit) {
3864                         firstMove = FALSE;
3865                         if (first.useColors) {
3866                           SendToProgram(gameMode == IcsPlayingWhite ?
3867                                         "white\ngo\n" :
3868                                         "black\ngo\n", &first);
3869                         } else {
3870                           SendToProgram("go\n", &first);
3871                         }
3872                         first.maybeThinking = TRUE;
3873                     }
3874                 }
3875             } else if (gameMode == IcsObserving || gameMode == IcsExamining) {
3876               if (moveList[moveNum - 1][0] == NULLCHAR) {
3877                 sprintf(str, _("Couldn't parse move \"%s\" from ICS"), move_str);
3878                 DisplayError(str, 0);
3879               } else {
3880                 if(gameInfo.variant == currentlyInitializedVariant) // [HGM] refrain sending moves engine can't understand!
3881                 SendMoveToProgram(moveNum - 1, &first);
3882               }
3883             }
3884         }
3885 #endif
3886     }
3887
3888     if (moveNum > 0 && !gotPremove && !appData.noGUI) {
3889         /* If move comes from a remote source, animate it.  If it
3890            isn't remote, it will have already been animated. */
3891         if (!pausing && !ics_user_moved && prevMove == moveNum - 1) {
3892             AnimateMove(boards[moveNum - 1], fromX, fromY, toX, toY);
3893         }
3894         if (!pausing && appData.highlightLastMove) {
3895             SetHighlights(fromX, fromY, toX, toY);
3896         }
3897     }
3898
3899     /* Start the clocks */
3900     whiteFlag = blackFlag = FALSE;
3901     appData.clockMode = !(basetime == 0 && increment == 0);
3902     if (ticking == 0) {
3903       ics_clock_paused = TRUE;
3904       StopClocks();
3905     } else if (ticking == 1) {
3906       ics_clock_paused = FALSE;
3907     }
3908     if (gameMode == IcsIdle ||
3909         relation == RELATION_OBSERVING_STATIC ||
3910         relation == RELATION_EXAMINING ||
3911         ics_clock_paused)
3912       DisplayBothClocks();
3913     else
3914       StartClocks();
3915
3916     /* Display opponents and material strengths */
3917     if (gameInfo.variant != VariantBughouse &&
3918         gameInfo.variant != VariantCrazyhouse && !appData.noGUI) {
3919         if (tinyLayout || smallLayout) {
3920             if(gameInfo.variant == VariantNormal)
3921                 sprintf(str, "%s(%d) %s(%d) {%d %d}",
3922                     gameInfo.white, white_stren, gameInfo.black, black_stren,
3923                     basetime, increment);
3924             else
3925                 sprintf(str, "%s(%d) %s(%d) {%d %d w%d}",
3926                     gameInfo.white, white_stren, gameInfo.black, black_stren,
3927                     basetime, increment, (int) gameInfo.variant);
3928         } else {
3929             if(gameInfo.variant == VariantNormal)
3930                 sprintf(str, "%s (%d) vs. %s (%d) {%d %d}",
3931                     gameInfo.white, white_stren, gameInfo.black, black_stren,
3932                     basetime, increment);
3933             else
3934                 sprintf(str, "%s (%d) vs. %s (%d) {%d %d %s}",
3935                     gameInfo.white, white_stren, gameInfo.black, black_stren,
3936                     basetime, increment, VariantName(gameInfo.variant));
3937         }
3938         DisplayTitle(str);
3939   if (appData.debugMode) {
3940     fprintf(debugFP, "Display title '%s, gameInfo.variant = %d'\n", str, gameInfo.variant);
3941   }
3942     }
3943
3944
3945     /* Display the board */
3946     if (!pausing && !appData.noGUI) {
3947
3948       if (appData.premove)
3949           if (!gotPremove ||
3950              ((gameMode == IcsPlayingWhite) && (WhiteOnMove(currentMove))) ||
3951              ((gameMode == IcsPlayingBlack) && (!WhiteOnMove(currentMove))))
3952               ClearPremoveHighlights();
3953
3954       DrawPosition(FALSE, boards[currentMove]);
3955       DisplayMove(moveNum - 1);
3956       if (appData.ringBellAfterMoves && /*!ics_user_moved*/ // [HGM] use absolute method to recognize own move
3957             !((gameMode == IcsPlayingWhite) && (!WhiteOnMove(moveNum)) ||
3958               (gameMode == IcsPlayingBlack) &&  (WhiteOnMove(moveNum))   ) ) {
3959         if(newMove) RingBell(); else PlayIcsUnfinishedSound();
3960       }
3961     }
3962
3963     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
3964 #if ZIPPY
3965     if(bookHit) { // [HGM] book: simulate book reply
3966         static char bookMove[MSG_SIZ]; // a bit generous?
3967
3968         programStats.nodes = programStats.depth = programStats.time =
3969         programStats.score = programStats.got_only_move = 0;
3970         sprintf(programStats.movelist, "%s (xbook)", bookHit);
3971
3972         strcpy(bookMove, "move ");
3973         strcat(bookMove, bookHit);
3974         HandleMachineMove(bookMove, &first);
3975     }
3976 #endif
3977 }
3978
3979 void
3980 GetMoveListEvent()
3981 {
3982     char buf[MSG_SIZ];
3983     if (appData.icsActive && gameMode != IcsIdle && ics_gamenum > 0) {
3984         ics_getting_history = H_REQUESTED;
3985         sprintf(buf, "%smoves %d\n", ics_prefix, ics_gamenum);
3986         SendToICS(buf);
3987     }
3988 }
3989
3990 void
3991 AnalysisPeriodicEvent(force)
3992      int force;
3993 {
3994     if (((programStats.ok_to_send == 0 || programStats.line_is_book)
3995          && !force) || !appData.periodicUpdates)
3996       return;
3997
3998     /* Send . command to Crafty to collect stats */
3999     SendToProgram(".\n", &first);
4000
4001     /* Don't send another until we get a response (this makes
4002        us stop sending to old Crafty's which don't understand
4003        the "." command (sending illegal cmds resets node count & time,
4004        which looks bad)) */
4005     programStats.ok_to_send = 0;
4006 }
4007
4008 void ics_update_width(new_width)
4009         int new_width;
4010 {
4011         ics_printf("set width %d\n", new_width);
4012 }
4013
4014 void
4015 SendMoveToProgram(moveNum, cps)
4016      int moveNum;
4017      ChessProgramState *cps;
4018 {
4019     char buf[MSG_SIZ];
4020
4021     if (cps->useUsermove) {
4022       SendToProgram("usermove ", cps);
4023     }
4024     if (cps->useSAN) {
4025       char *space;
4026       if ((space = strchr(parseList[moveNum], ' ')) != NULL) {
4027         int len = space - parseList[moveNum];
4028         memcpy(buf, parseList[moveNum], len);
4029         buf[len++] = '\n';
4030         buf[len] = NULLCHAR;
4031       } else {
4032         sprintf(buf, "%s\n", parseList[moveNum]);
4033       }
4034       SendToProgram(buf, cps);
4035     } else {
4036       if(cps->alphaRank) { /* [HGM] shogi: temporarily convert to shogi coordinates before sending */
4037         AlphaRank(moveList[moveNum], 4);
4038         SendToProgram(moveList[moveNum], cps);
4039         AlphaRank(moveList[moveNum], 4); // and back
4040       } else
4041       /* Added by Tord: Send castle moves in "O-O" in FRC games if required by
4042        * the engine. It would be nice to have a better way to identify castle
4043        * moves here. */
4044       if((gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom)
4045                                                                          && cps->useOOCastle) {
4046         int fromX = moveList[moveNum][0] - AAA;
4047         int fromY = moveList[moveNum][1] - ONE;
4048         int toX = moveList[moveNum][2] - AAA;
4049         int toY = moveList[moveNum][3] - ONE;
4050         if((boards[moveNum][fromY][fromX] == WhiteKing
4051             && boards[moveNum][toY][toX] == WhiteRook)
4052            || (boards[moveNum][fromY][fromX] == BlackKing
4053                && boards[moveNum][toY][toX] == BlackRook)) {
4054           if(toX > fromX) SendToProgram("O-O\n", cps);
4055           else SendToProgram("O-O-O\n", cps);
4056         }
4057         else SendToProgram(moveList[moveNum], cps);
4058       }
4059       else SendToProgram(moveList[moveNum], cps);
4060       /* End of additions by Tord */
4061     }
4062
4063     /* [HGM] setting up the opening has brought engine in force mode! */
4064     /*       Send 'go' if we are in a mode where machine should play. */
4065     if( (moveNum == 0 && setboardSpoiledMachineBlack && cps == &first) &&
4066         (gameMode == TwoMachinesPlay   ||
4067 #ifdef ZIPPY
4068          gameMode == IcsPlayingBlack     || gameMode == IcsPlayingWhite ||
4069 #endif
4070          gameMode == MachinePlaysBlack || gameMode == MachinePlaysWhite) ) {
4071         SendToProgram("go\n", cps);
4072   if (appData.debugMode) {
4073     fprintf(debugFP, "(extra)\n");
4074   }
4075     }
4076     setboardSpoiledMachineBlack = 0;
4077 }
4078
4079 void
4080 SendMoveToICS(moveType, fromX, fromY, toX, toY)
4081      ChessMove moveType;
4082      int fromX, fromY, toX, toY;
4083 {
4084     char user_move[MSG_SIZ];
4085
4086     switch (moveType) {
4087       default:
4088         sprintf(user_move, _("say Internal error; bad moveType %d (%d,%d-%d,%d)"),
4089                 (int)moveType, fromX, fromY, toX, toY);
4090         DisplayError(user_move + strlen("say "), 0);
4091         break;
4092       case WhiteKingSideCastle:
4093       case BlackKingSideCastle:
4094       case WhiteQueenSideCastleWild:
4095       case BlackQueenSideCastleWild:
4096       /* PUSH Fabien */
4097       case WhiteHSideCastleFR:
4098       case BlackHSideCastleFR:
4099       /* POP Fabien */
4100         sprintf(user_move, "o-o\n");
4101         break;
4102       case WhiteQueenSideCastle:
4103       case BlackQueenSideCastle:
4104       case WhiteKingSideCastleWild:
4105       case BlackKingSideCastleWild:
4106       /* PUSH Fabien */
4107       case WhiteASideCastleFR:
4108       case BlackASideCastleFR:
4109       /* POP Fabien */
4110         sprintf(user_move, "o-o-o\n");
4111         break;
4112       case WhitePromotionQueen:
4113       case BlackPromotionQueen:
4114       case WhitePromotionRook:
4115       case BlackPromotionRook:
4116       case WhitePromotionBishop:
4117       case BlackPromotionBishop:
4118       case WhitePromotionKnight:
4119       case BlackPromotionKnight:
4120       case WhitePromotionKing:
4121       case BlackPromotionKing:
4122       case WhitePromotionChancellor:
4123       case BlackPromotionChancellor:
4124       case WhitePromotionArchbishop:
4125       case BlackPromotionArchbishop:
4126         if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier)
4127             sprintf(user_move, "%c%c%c%c=%c\n",
4128                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4129                 PieceToChar(WhiteFerz));
4130         else if(gameInfo.variant == VariantGreat)
4131             sprintf(user_move, "%c%c%c%c=%c\n",
4132                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4133                 PieceToChar(WhiteMan));
4134         else
4135             sprintf(user_move, "%c%c%c%c=%c\n",
4136                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4137                 PieceToChar(PromoPiece(moveType)));
4138         break;
4139       case WhiteDrop:
4140       case BlackDrop:
4141         sprintf(user_move, "%c@%c%c\n",
4142                 ToUpper(PieceToChar((ChessSquare) fromX)),
4143                 AAA + toX, ONE + toY);
4144         break;
4145       case NormalMove:
4146       case WhiteCapturesEnPassant:
4147       case BlackCapturesEnPassant:
4148       case IllegalMove:  /* could be a variant we don't quite understand */
4149         sprintf(user_move, "%c%c%c%c\n",
4150                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY);
4151         break;
4152     }
4153     SendToICS(user_move);
4154     if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
4155         ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
4156 }
4157
4158 void
4159 CoordsToComputerAlgebraic(rf, ff, rt, ft, promoChar, move)
4160      int rf, ff, rt, ft;
4161      char promoChar;
4162      char move[7];
4163 {
4164     if (rf == DROP_RANK) {
4165         sprintf(move, "%c@%c%c\n",
4166                 ToUpper(PieceToChar((ChessSquare) ff)), AAA + ft, ONE + rt);
4167     } else {
4168         if (promoChar == 'x' || promoChar == NULLCHAR) {
4169             sprintf(move, "%c%c%c%c\n",
4170                     AAA + ff, ONE + rf, AAA + ft, ONE + rt);
4171         } else {
4172             sprintf(move, "%c%c%c%c%c\n",
4173                     AAA + ff, ONE + rf, AAA + ft, ONE + rt, promoChar);
4174         }
4175     }
4176 }
4177
4178 void
4179 ProcessICSInitScript(f)
4180      FILE *f;
4181 {
4182     char buf[MSG_SIZ];
4183
4184     while (fgets(buf, MSG_SIZ, f)) {
4185         SendToICSDelayed(buf,(long)appData.msLoginDelay);
4186     }
4187
4188     fclose(f);
4189 }
4190
4191
4192 /* [HGM] Shogi move preprocessor: swap digits for letters, vice versa */
4193 void
4194 AlphaRank(char *move, int n)
4195 {
4196 //    char *p = move, c; int x, y;
4197
4198     if (appData.debugMode) {
4199         fprintf(debugFP, "alphaRank(%s,%d)\n", move, n);
4200     }
4201
4202     if(move[1]=='*' &&
4203        move[2]>='0' && move[2]<='9' &&
4204        move[3]>='a' && move[3]<='x'    ) {
4205         move[1] = '@';
4206         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
4207         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
4208     } else
4209     if(move[0]>='0' && move[0]<='9' &&
4210        move[1]>='a' && move[1]<='x' &&
4211        move[2]>='0' && move[2]<='9' &&
4212        move[3]>='a' && move[3]<='x'    ) {
4213         /* input move, Shogi -> normal */
4214         move[0] = BOARD_RGHT  -1 - (move[0]-'1') + AAA;
4215         move[1] = BOARD_HEIGHT-1 - (move[1]-'a') + ONE;
4216         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
4217         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
4218     } else
4219     if(move[1]=='@' &&
4220        move[3]>='0' && move[3]<='9' &&
4221        move[2]>='a' && move[2]<='x'    ) {
4222         move[1] = '*';
4223         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
4224         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
4225     } else
4226     if(
4227        move[0]>='a' && move[0]<='x' &&
4228        move[3]>='0' && move[3]<='9' &&
4229        move[2]>='a' && move[2]<='x'    ) {
4230          /* output move, normal -> Shogi */
4231         move[0] = BOARD_RGHT - 1 - (move[0]-AAA) + '1';
4232         move[1] = BOARD_HEIGHT-1 - (move[1]-ONE) + 'a';
4233         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
4234         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
4235         if(move[4] == PieceToChar(BlackQueen)) move[4] = '+';
4236     }
4237     if (appData.debugMode) {
4238         fprintf(debugFP, "   out = '%s'\n", move);
4239     }
4240 }
4241
4242 /* Parser for moves from gnuchess, ICS, or user typein box */
4243 Boolean
4244 ParseOneMove(move, moveNum, moveType, fromX, fromY, toX, toY, promoChar)
4245      char *move;
4246      int moveNum;
4247      ChessMove *moveType;
4248      int *fromX, *fromY, *toX, *toY;
4249      char *promoChar;
4250 {
4251     if (appData.debugMode) {
4252         fprintf(debugFP, "move to parse: %s\n", move);
4253     }
4254     *moveType = yylexstr(moveNum, move);
4255
4256     switch (*moveType) {
4257       case WhitePromotionChancellor:
4258       case BlackPromotionChancellor:
4259       case WhitePromotionArchbishop:
4260       case BlackPromotionArchbishop:
4261       case WhitePromotionQueen:
4262       case BlackPromotionQueen:
4263       case WhitePromotionRook:
4264       case BlackPromotionRook:
4265       case WhitePromotionBishop:
4266       case BlackPromotionBishop:
4267       case WhitePromotionKnight:
4268       case BlackPromotionKnight:
4269       case WhitePromotionKing:
4270       case BlackPromotionKing:
4271       case NormalMove:
4272       case WhiteCapturesEnPassant:
4273       case BlackCapturesEnPassant:
4274       case WhiteKingSideCastle:
4275       case WhiteQueenSideCastle:
4276       case BlackKingSideCastle:
4277       case BlackQueenSideCastle:
4278       case WhiteKingSideCastleWild:
4279       case WhiteQueenSideCastleWild:
4280       case BlackKingSideCastleWild:
4281       case BlackQueenSideCastleWild:
4282       /* Code added by Tord: */
4283       case WhiteHSideCastleFR:
4284       case WhiteASideCastleFR:
4285       case BlackHSideCastleFR:
4286       case BlackASideCastleFR:
4287       /* End of code added by Tord */
4288       case IllegalMove:         /* bug or odd chess variant */
4289         *fromX = currentMoveString[0] - AAA;
4290         *fromY = currentMoveString[1] - ONE;
4291         *toX = currentMoveString[2] - AAA;
4292         *toY = currentMoveString[3] - ONE;
4293         *promoChar = currentMoveString[4];
4294         if (*fromX < BOARD_LEFT || *fromX >= BOARD_RGHT || *fromY < 0 || *fromY >= BOARD_HEIGHT ||
4295             *toX < BOARD_LEFT || *toX >= BOARD_RGHT || *toY < 0 || *toY >= BOARD_HEIGHT) {
4296     if (appData.debugMode) {
4297         fprintf(debugFP, "Off-board move (%d,%d)-(%d,%d)%c, type = %d\n", *fromX, *fromY, *toX, *toY, *promoChar, *moveType);
4298     }
4299             *fromX = *fromY = *toX = *toY = 0;
4300             return FALSE;
4301         }
4302         if (appData.testLegality) {
4303           return (*moveType != IllegalMove);
4304         } else {
4305           return !(fromX == fromY && toX == toY);
4306         }
4307
4308       case WhiteDrop:
4309       case BlackDrop:
4310         *fromX = *moveType == WhiteDrop ?
4311           (int) CharToPiece(ToUpper(currentMoveString[0])) :
4312           (int) CharToPiece(ToLower(currentMoveString[0]));
4313         *fromY = DROP_RANK;
4314         *toX = currentMoveString[2] - AAA;
4315         *toY = currentMoveString[3] - ONE;
4316         *promoChar = NULLCHAR;
4317         return TRUE;
4318
4319       case AmbiguousMove:
4320       case ImpossibleMove:
4321       case (ChessMove) 0:       /* end of file */
4322       case ElapsedTime:
4323       case Comment:
4324       case PGNTag:
4325       case NAG:
4326       case WhiteWins:
4327       case BlackWins:
4328       case GameIsDrawn:
4329       default:
4330     if (appData.debugMode) {
4331         fprintf(debugFP, "Impossible move %s, type = %d\n", currentMoveString, *moveType);
4332     }
4333         /* bug? */
4334         *fromX = *fromY = *toX = *toY = 0;
4335         *promoChar = NULLCHAR;
4336         return FALSE;
4337     }
4338 }
4339
4340 // [HGM] shuffle: a general way to suffle opening setups, applicable to arbitrary variants.
4341 // All positions will have equal probability, but the current method will not provide a unique
4342 // numbering scheme for arrays that contain 3 or more pieces of the same kind.
4343 #define DARK 1
4344 #define LITE 2
4345 #define ANY 3
4346
4347 int squaresLeft[4];
4348 int piecesLeft[(int)BlackPawn];
4349 int seed, nrOfShuffles;
4350
4351 void GetPositionNumber()
4352 {       // sets global variable seed
4353         int i;
4354
4355         seed = appData.defaultFrcPosition;
4356         if(seed < 0) { // randomize based on time for negative FRC position numbers
4357                 for(i=0; i<50; i++) seed += random();
4358                 seed = random() ^ random() >> 8 ^ random() << 8;
4359                 if(seed<0) seed = -seed;
4360         }
4361 }
4362
4363 int put(Board board, int pieceType, int rank, int n, int shade)
4364 // put the piece on the (n-1)-th empty squares of the given shade
4365 {
4366         int i;
4367
4368         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
4369                 if( (((i-BOARD_LEFT)&1)+1) & shade && board[rank][i] == EmptySquare && n-- == 0) {
4370                         board[rank][i] = (ChessSquare) pieceType;
4371                         squaresLeft[((i-BOARD_LEFT)&1) + 1]--;
4372                         squaresLeft[ANY]--;
4373                         piecesLeft[pieceType]--;
4374                         return i;
4375                 }
4376         }
4377         return -1;
4378 }
4379
4380
4381 void AddOnePiece(Board board, int pieceType, int rank, int shade)
4382 // calculate where the next piece goes, (any empty square), and put it there
4383 {
4384         int i;
4385
4386         i = seed % squaresLeft[shade];
4387         nrOfShuffles *= squaresLeft[shade];
4388         seed /= squaresLeft[shade];
4389         put(board, pieceType, rank, i, shade);
4390 }
4391
4392 void AddTwoPieces(Board board, int pieceType, int rank)
4393 // calculate where the next 2 identical pieces go, (any empty square), and put it there
4394 {
4395         int i, n=squaresLeft[ANY], j=n-1, k;
4396
4397         k = n*(n-1)/2; // nr of possibilities, not counting permutations
4398         i = seed % k;  // pick one
4399         nrOfShuffles *= k;
4400         seed /= k;
4401         while(i >= j) i -= j--;
4402         j = n - 1 - j; i += j;
4403         put(board, pieceType, rank, j, ANY);
4404         put(board, pieceType, rank, i, ANY);
4405 }
4406
4407 void SetUpShuffle(Board board, int number)
4408 {
4409         int i, p, first=1;
4410
4411         GetPositionNumber(); nrOfShuffles = 1;
4412
4413         squaresLeft[DARK] = (BOARD_RGHT - BOARD_LEFT + 1)/2;
4414         squaresLeft[ANY]  = BOARD_RGHT - BOARD_LEFT;
4415         squaresLeft[LITE] = squaresLeft[ANY] - squaresLeft[DARK];
4416
4417         for(p = 0; p<=(int)WhiteKing; p++) piecesLeft[p] = 0;
4418
4419         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // count pieces and clear board
4420             p = (int) board[0][i];
4421             if(p < (int) BlackPawn) piecesLeft[p] ++;
4422             board[0][i] = EmptySquare;
4423         }
4424
4425         if(PosFlags(0) & F_ALL_CASTLE_OK) {
4426             // shuffles restricted to allow normal castling put KRR first
4427             if(piecesLeft[(int)WhiteKing]) // King goes rightish of middle
4428                 put(board, WhiteKing, 0, (gameInfo.boardWidth+1)/2, ANY);
4429             else if(piecesLeft[(int)WhiteUnicorn]) // in Knightmate Unicorn castles
4430                 put(board, WhiteUnicorn, 0, (gameInfo.boardWidth+1)/2, ANY);
4431             if(piecesLeft[(int)WhiteRook]) // First supply a Rook for K-side castling
4432                 put(board, WhiteRook, 0, gameInfo.boardWidth-2, ANY);
4433             if(piecesLeft[(int)WhiteRook]) // Then supply a Rook for Q-side castling
4434                 put(board, WhiteRook, 0, 0, ANY);
4435             // in variants with super-numerary Kings and Rooks, we leave these for the shuffle
4436         }
4437
4438         if(((BOARD_RGHT-BOARD_LEFT) & 1) == 0)
4439             // only for even boards make effort to put pairs of colorbound pieces on opposite colors
4440             for(p = (int) WhiteKing; p > (int) WhitePawn; p--) {
4441                 if(p != (int) WhiteBishop && p != (int) WhiteFerz && p != (int) WhiteAlfil) continue;
4442                 while(piecesLeft[p] >= 2) {
4443                     AddOnePiece(board, p, 0, LITE);
4444                     AddOnePiece(board, p, 0, DARK);
4445                 }
4446                 // Odd color-bound pieces are shuffled with the rest (to not run out of paired squares)
4447             }
4448
4449         for(p = (int) WhiteKing - 2; p > (int) WhitePawn; p--) {
4450             // Remaining pieces (non-colorbound, or odd color bound) can be put anywhere
4451             // but we leave King and Rooks for last, to possibly obey FRC restriction
4452             if(p == (int)WhiteRook) continue;
4453             while(piecesLeft[p] >= 2) AddTwoPieces(board, p, 0); // add in pairs, for not counting permutations
4454             if(piecesLeft[p]) AddOnePiece(board, p, 0, ANY);     // add the odd piece
4455         }
4456
4457         // now everything is placed, except perhaps King (Unicorn) and Rooks
4458
4459         if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
4460             // Last King gets castling rights
4461             while(piecesLeft[(int)WhiteUnicorn]) {
4462                 i = put(board, WhiteUnicorn, 0, piecesLeft[(int)WhiteRook]/2, ANY);
4463                 initialRights[2]  = initialRights[5]  = castlingRights[0][2] = castlingRights[0][5] = i;
4464             }
4465
4466             while(piecesLeft[(int)WhiteKing]) {
4467                 i = put(board, WhiteKing, 0, piecesLeft[(int)WhiteRook]/2, ANY);
4468                 initialRights[2]  = initialRights[5]  = castlingRights[0][2] = castlingRights[0][5] = i;
4469             }
4470
4471
4472         } else {
4473             while(piecesLeft[(int)WhiteKing])    AddOnePiece(board, WhiteKing, 0, ANY);
4474             while(piecesLeft[(int)WhiteUnicorn]) AddOnePiece(board, WhiteUnicorn, 0, ANY);
4475         }
4476
4477         // Only Rooks can be left; simply place them all
4478         while(piecesLeft[(int)WhiteRook]) {
4479                 i = put(board, WhiteRook, 0, 0, ANY);
4480                 if(PosFlags(0) & F_FRC_TYPE_CASTLING) { // first and last Rook get FRC castling rights
4481                         if(first) {
4482                                 first=0;
4483                                 initialRights[1]  = initialRights[4]  = castlingRights[0][1] = castlingRights[0][4] = i;
4484                         }
4485                         initialRights[0]  = initialRights[3]  = castlingRights[0][0] = castlingRights[0][3] = i;
4486                 }
4487         }
4488         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // copy black from white
4489             board[BOARD_HEIGHT-1][i] =  (int) board[0][i] < BlackPawn ? WHITE_TO_BLACK board[0][i] : EmptySquare;
4490         }
4491
4492         if(number >= 0) appData.defaultFrcPosition %= nrOfShuffles; // normalize
4493 }
4494
4495 int SetCharTable( char *table, const char * map )
4496 /* [HGM] moved here from winboard.c because of its general usefulness */
4497 /*       Basically a safe strcpy that uses the last character as King */
4498 {
4499     int result = FALSE; int NrPieces;
4500
4501     if( map != NULL && (NrPieces=strlen(map)) <= (int) EmptySquare
4502                     && NrPieces >= 12 && !(NrPieces&1)) {
4503         int i; /* [HGM] Accept even length from 12 to 34 */
4504
4505         for( i=0; i<(int) EmptySquare; i++ ) table[i] = '.';
4506         for( i=0; i<NrPieces/2-1; i++ ) {
4507             table[i] = map[i];
4508             table[i + (int)BlackPawn - (int) WhitePawn] = map[i+NrPieces/2];
4509         }
4510         table[(int) WhiteKing]  = map[NrPieces/2-1];
4511         table[(int) BlackKing]  = map[NrPieces-1];
4512
4513         result = TRUE;
4514     }
4515
4516     return result;
4517 }
4518
4519 void Prelude(Board board)
4520 {       // [HGM] superchess: random selection of exo-pieces
4521         int i, j, k; ChessSquare p;
4522         static ChessSquare exoPieces[4] = { WhiteAngel, WhiteMarshall, WhiteSilver, WhiteLance };
4523
4524         GetPositionNumber(); // use FRC position number
4525
4526         if(appData.pieceToCharTable != NULL) { // select pieces to participate from given char table
4527             SetCharTable(pieceToChar, appData.pieceToCharTable);
4528             for(i=(int)WhiteQueen+1, j=0; i<(int)WhiteKing && j<4; i++)
4529                 if(PieceToChar((ChessSquare)i) != '.') exoPieces[j++] = (ChessSquare) i;
4530         }
4531
4532         j = seed%4;                 seed /= 4;
4533         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
4534         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
4535         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
4536         j = seed%3 + (seed%3 >= j); seed /= 3;
4537         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
4538         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
4539         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
4540         j = seed%3;                 seed /= 3;
4541         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
4542         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
4543         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
4544         j = seed%2 + (seed%2 >= j); seed /= 2;
4545         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
4546         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
4547         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
4548         j = seed%4; seed /= 4; put(board, exoPieces[3],    0, j, ANY);
4549         j = seed%3; seed /= 3; put(board, exoPieces[2],   0, j, ANY);
4550         j = seed%2; seed /= 2; put(board, exoPieces[1], 0, j, ANY);
4551         put(board, exoPieces[0],    0, 0, ANY);
4552         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) board[BOARD_HEIGHT-1][i] = WHITE_TO_BLACK board[0][i];
4553 }
4554
4555 void
4556 InitPosition(redraw)
4557      int redraw;
4558 {
4559     ChessSquare (* pieces)[BOARD_SIZE];
4560     int i, j, pawnRow, overrule,
4561     oldx = gameInfo.boardWidth,
4562     oldy = gameInfo.boardHeight,
4563     oldh = gameInfo.holdingsWidth,
4564     oldv = gameInfo.variant;
4565
4566     if(appData.icsActive) shuffleOpenings = FALSE; // [HGM] shuffle: in ICS mode, only shuffle on ICS request
4567
4568     /* [AS] Initialize pv info list [HGM] and game status */
4569     {
4570         for( i=0; i<MAX_MOVES; i++ ) {
4571             pvInfoList[i].depth = 0;
4572             epStatus[i]=EP_NONE;
4573             for( j=0; j<BOARD_SIZE; j++ ) castlingRights[i][j] = -1;
4574         }
4575
4576         initialRulePlies = 0; /* 50-move counter start */
4577
4578         castlingRank[0] = castlingRank[1] = castlingRank[2] = 0;
4579         castlingRank[3] = castlingRank[4] = castlingRank[5] = BOARD_HEIGHT-1;
4580     }
4581
4582
4583     /* [HGM] logic here is completely changed. In stead of full positions */
4584     /* the initialized data only consist of the two backranks. The switch */
4585     /* selects which one we will use, which is than copied to the Board   */
4586     /* initialPosition, which for the rest is initialized by Pawns and    */
4587     /* empty squares. This initial position is then copied to boards[0],  */
4588     /* possibly after shuffling, so that it remains available.            */
4589
4590     gameInfo.holdingsWidth = 0; /* default board sizes */
4591     gameInfo.boardWidth    = 8;
4592     gameInfo.boardHeight   = 8;
4593     gameInfo.holdingsSize  = 0;
4594     nrCastlingRights = -1; /* [HGM] Kludge to indicate default should be used */
4595     for(i=0; i<BOARD_SIZE; i++) initialRights[i] = -1; /* but no rights yet */
4596     SetCharTable(pieceToChar, "PNBRQ...........Kpnbrq...........k");
4597
4598     switch (gameInfo.variant) {
4599     case VariantFischeRandom:
4600       shuffleOpenings = TRUE;
4601     default:
4602       pieces = FIDEArray;
4603       break;
4604     case VariantShatranj:
4605       pieces = ShatranjArray;
4606       nrCastlingRights = 0;
4607       SetCharTable(pieceToChar, "PN.R.QB...Kpn.r.qb...k");
4608       break;
4609     case VariantTwoKings:
4610       pieces = twoKingsArray;
4611       break;
4612     case VariantCapaRandom:
4613       shuffleOpenings = TRUE;
4614     case VariantCapablanca:
4615       pieces = CapablancaArray;
4616       gameInfo.boardWidth = 10;
4617       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
4618       break;
4619     case VariantGothic:
4620       pieces = GothicArray;
4621       gameInfo.boardWidth = 10;
4622       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
4623       break;
4624     case VariantJanus:
4625       pieces = JanusArray;
4626       gameInfo.boardWidth = 10;
4627       SetCharTable(pieceToChar, "PNBRQ..JKpnbrq..jk");
4628       nrCastlingRights = 6;
4629         castlingRights[0][0] = initialRights[0] = BOARD_RGHT-1;
4630         castlingRights[0][1] = initialRights[1] = BOARD_LEFT;
4631         castlingRights[0][2] = initialRights[2] =(BOARD_WIDTH-1)>>1;
4632         castlingRights[0][3] = initialRights[3] = BOARD_RGHT-1;
4633         castlingRights[0][4] = initialRights[4] = BOARD_LEFT;
4634         castlingRights[0][5] = initialRights[5] =(BOARD_WIDTH-1)>>1;
4635       break;
4636     case VariantFalcon:
4637       pieces = FalconArray;
4638       gameInfo.boardWidth = 10;
4639       SetCharTable(pieceToChar, "PNBRQ.............FKpnbrq.............fk");
4640       break;
4641     case VariantXiangqi:
4642       pieces = XiangqiArray;
4643       gameInfo.boardWidth  = 9;
4644       gameInfo.boardHeight = 10;
4645       nrCastlingRights = 0;
4646       SetCharTable(pieceToChar, "PH.R.AE..K.C.ph.r.ae..k.c.");
4647       break;
4648     case VariantShogi:
4649       pieces = ShogiArray;
4650       gameInfo.boardWidth  = 9;
4651       gameInfo.boardHeight = 9;
4652       gameInfo.holdingsSize = 7;
4653       nrCastlingRights = 0;
4654       SetCharTable(pieceToChar, "PNBRLS...G.++++++Kpnbrls...g.++++++k");
4655       break;
4656     case VariantCourier:
4657       pieces = CourierArray;
4658       gameInfo.boardWidth  = 12;
4659       nrCastlingRights = 0;
4660       SetCharTable(pieceToChar, "PNBR.FE..WMKpnbr.fe..wmk");
4661       for(i=0; i<BOARD_SIZE; i++) initialRights[i] = -1;
4662       break;
4663     case VariantKnightmate:
4664       pieces = KnightmateArray;
4665       SetCharTable(pieceToChar, "P.BRQ.....M.........K.p.brq.....m.........k.");
4666       break;
4667     case VariantFairy:
4668       pieces = fairyArray;
4669       SetCharTable(pieceToChar, "PNBRQFEACWMOHIJGDVSLUKpnbrqfeacwmohijgdvsluk");
4670       break;
4671     case VariantGreat:
4672       pieces = GreatArray;
4673       gameInfo.boardWidth = 10;
4674       SetCharTable(pieceToChar, "PN....E...S..HWGMKpn....e...s..hwgmk");
4675       gameInfo.holdingsSize = 8;
4676       break;
4677     case VariantSuper:
4678       pieces = FIDEArray;
4679       SetCharTable(pieceToChar, "PNBRQ..SE.......V.AKpnbrq..se.......v.ak");
4680       gameInfo.holdingsSize = 8;
4681       startedFromSetupPosition = TRUE;
4682       break;
4683     case VariantCrazyhouse:
4684     case VariantBughouse:
4685       pieces = FIDEArray;
4686       SetCharTable(pieceToChar, "PNBRQ.......~~~~Kpnbrq.......~~~~k");
4687       gameInfo.holdingsSize = 5;
4688       break;
4689     case VariantWildCastle:
4690       pieces = FIDEArray;
4691       /* !!?shuffle with kings guaranteed to be on d or e file */
4692       shuffleOpenings = 1;
4693       break;
4694     case VariantNoCastle:
4695       pieces = FIDEArray;
4696       nrCastlingRights = 0;
4697       for(i=0; i<BOARD_SIZE; i++) initialRights[i] = -1;
4698       /* !!?unconstrained back-rank shuffle */
4699       shuffleOpenings = 1;
4700       break;
4701     }
4702
4703     overrule = 0;
4704     if(appData.NrFiles >= 0) {
4705         if(gameInfo.boardWidth != appData.NrFiles) overrule++;
4706         gameInfo.boardWidth = appData.NrFiles;
4707     }
4708     if(appData.NrRanks >= 0) {
4709         gameInfo.boardHeight = appData.NrRanks;
4710     }
4711     if(appData.holdingsSize >= 0) {
4712         i = appData.holdingsSize;
4713         if(i > gameInfo.boardHeight) i = gameInfo.boardHeight;
4714         gameInfo.holdingsSize = i;
4715     }
4716     if(gameInfo.holdingsSize) gameInfo.holdingsWidth = 2;
4717     if(BOARD_HEIGHT > BOARD_SIZE || BOARD_WIDTH > BOARD_SIZE)
4718         DisplayFatalError(_("Recompile to support this BOARD_SIZE!"), 0, 2);
4719
4720     pawnRow = gameInfo.boardHeight - 7; /* seems to work in all common variants */
4721     if(pawnRow < 1) pawnRow = 1;
4722
4723     /* User pieceToChar list overrules defaults */
4724     if(appData.pieceToCharTable != NULL)
4725         SetCharTable(pieceToChar, appData.pieceToCharTable);
4726
4727     for( j=0; j<BOARD_WIDTH; j++ ) { ChessSquare s = EmptySquare;
4728
4729         if(j==BOARD_LEFT-1 || j==BOARD_RGHT)
4730             s = (ChessSquare) 0; /* account holding counts in guard band */
4731         for( i=0; i<BOARD_HEIGHT; i++ )
4732             initialPosition[i][j] = s;
4733
4734         if(j < BOARD_LEFT || j >= BOARD_RGHT || overrule) continue;
4735         initialPosition[0][j] = pieces[0][j-gameInfo.holdingsWidth];
4736         initialPosition[pawnRow][j] = WhitePawn;
4737         initialPosition[BOARD_HEIGHT-pawnRow-1][j] = BlackPawn;
4738         if(gameInfo.variant == VariantXiangqi) {
4739             if(j&1) {
4740                 initialPosition[pawnRow][j] =
4741                 initialPosition[BOARD_HEIGHT-pawnRow-1][j] = EmptySquare;
4742                 if(j==BOARD_LEFT+1 || j>=BOARD_RGHT-2) {
4743                    initialPosition[2][j] = WhiteCannon;
4744                    initialPosition[BOARD_HEIGHT-3][j] = BlackCannon;
4745                 }
4746             }
4747         }
4748         initialPosition[BOARD_HEIGHT-1][j] =  pieces[1][j-gameInfo.holdingsWidth];
4749     }
4750     if( (gameInfo.variant == VariantShogi) && !overrule ) {
4751
4752             j=BOARD_LEFT+1;
4753             initialPosition[1][j] = WhiteBishop;
4754             initialPosition[BOARD_HEIGHT-2][j] = BlackRook;
4755             j=BOARD_RGHT-2;
4756             initialPosition[1][j] = WhiteRook;
4757             initialPosition[BOARD_HEIGHT-2][j] = BlackBishop;
4758     }
4759
4760     if( nrCastlingRights == -1) {
4761         /* [HGM] Build normal castling rights (must be done after board sizing!) */
4762         /*       This sets default castling rights from none to normal corners   */
4763         /* Variants with other castling rights must set them themselves above    */
4764         nrCastlingRights = 6;
4765
4766         castlingRights[0][0] = initialRights[0] = BOARD_RGHT-1;
4767         castlingRights[0][1] = initialRights[1] = BOARD_LEFT;
4768         castlingRights[0][2] = initialRights[2] = BOARD_WIDTH>>1;
4769         castlingRights[0][3] = initialRights[3] = BOARD_RGHT-1;
4770         castlingRights[0][4] = initialRights[4] = BOARD_LEFT;
4771         castlingRights[0][5] = initialRights[5] = BOARD_WIDTH>>1;
4772      }
4773
4774      if(gameInfo.variant == VariantSuper) Prelude(initialPosition);
4775      if(gameInfo.variant == VariantGreat) { // promotion commoners
4776         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-1] = WhiteMan;
4777         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-2] = 9;
4778         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][0] = BlackMan;
4779         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][1] = 9;
4780      }
4781   if (appData.debugMode) {
4782     fprintf(debugFP, "shuffleOpenings = %d\n", shuffleOpenings);
4783   }
4784     if(shuffleOpenings) {
4785         SetUpShuffle(initialPosition, appData.defaultFrcPosition);
4786         startedFromSetupPosition = TRUE;
4787     }
4788     if(startedFromPositionFile) {
4789       /* [HGM] loadPos: use PositionFile for every new game */
4790       CopyBoard(initialPosition, filePosition);
4791       for(i=0; i<nrCastlingRights; i++)
4792           castlingRights[0][i] = initialRights[i] = fileRights[i];
4793       startedFromSetupPosition = TRUE;
4794     }
4795
4796     CopyBoard(boards[0], initialPosition);
4797
4798     if(oldx != gameInfo.boardWidth ||
4799        oldy != gameInfo.boardHeight ||
4800        oldh != gameInfo.holdingsWidth
4801 #ifdef GOTHIC
4802        || oldv == VariantGothic ||        // For licensing popups
4803        gameInfo.variant == VariantGothic
4804 #endif
4805 #ifdef FALCON
4806        || oldv == VariantFalcon ||
4807        gameInfo.variant == VariantFalcon
4808 #endif
4809                                          )
4810             InitDrawingSizes(-2 ,0);
4811
4812     if (redraw)
4813       DrawPosition(TRUE, boards[currentMove]);
4814 }
4815
4816 void
4817 SendBoard(cps, moveNum)
4818      ChessProgramState *cps;
4819      int moveNum;
4820 {
4821     char message[MSG_SIZ];
4822
4823     if (cps->useSetboard) {
4824       char* fen = PositionToFEN(moveNum, cps->fenOverride);
4825       sprintf(message, "setboard %s\n", fen);
4826       SendToProgram(message, cps);
4827       free(fen);
4828
4829     } else {
4830       ChessSquare *bp;
4831       int i, j;
4832       /* Kludge to set black to move, avoiding the troublesome and now
4833        * deprecated "black" command.
4834        */
4835       if (!WhiteOnMove(moveNum)) SendToProgram("a2a3\n", cps);
4836
4837       SendToProgram("edit\n", cps);
4838       SendToProgram("#\n", cps);
4839       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
4840         bp = &boards[moveNum][i][BOARD_LEFT];
4841         for (j = BOARD_LEFT; j < BOARD_RGHT; j++, bp++) {
4842           if ((int) *bp < (int) BlackPawn) {
4843             sprintf(message, "%c%c%c\n", PieceToChar(*bp),
4844                     AAA + j, ONE + i);
4845             if(message[0] == '+' || message[0] == '~') {
4846                 sprintf(message, "%c%c%c+\n",
4847                         PieceToChar((ChessSquare)(DEMOTED *bp)),
4848                         AAA + j, ONE + i);
4849             }
4850             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
4851                 message[1] = BOARD_RGHT   - 1 - j + '1';
4852                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
4853             }
4854             SendToProgram(message, cps);
4855           }
4856         }
4857       }
4858
4859       SendToProgram("c\n", cps);
4860       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
4861         bp = &boards[moveNum][i][BOARD_LEFT];
4862         for (j = BOARD_LEFT; j < BOARD_RGHT; j++, bp++) {
4863           if (((int) *bp != (int) EmptySquare)
4864               && ((int) *bp >= (int) BlackPawn)) {
4865             sprintf(message, "%c%c%c\n", ToUpper(PieceToChar(*bp)),
4866                     AAA + j, ONE + i);
4867             if(message[0] == '+' || message[0] == '~') {
4868                 sprintf(message, "%c%c%c+\n",
4869                         PieceToChar((ChessSquare)(DEMOTED *bp)),
4870                         AAA + j, ONE + i);
4871             }
4872             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
4873                 message[1] = BOARD_RGHT   - 1 - j + '1';
4874                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
4875             }
4876             SendToProgram(message, cps);
4877           }
4878         }
4879       }
4880
4881       SendToProgram(".\n", cps);
4882     }
4883     setboardSpoiledMachineBlack = 0; /* [HGM] assume WB 4.2.7 already solves this after sending setboard */
4884 }
4885
4886 int
4887 HasPromotionChoice(int fromX, int fromY, int toX, int toY, char *promoChoice)
4888 {
4889     /* [HGM] rewritten IsPromotion to only flag promotions that offer a choice */
4890     /* [HGM] add Shogi promotions */
4891     int promotionZoneSize=1, highestPromotingPiece = (int)WhitePawn;
4892     ChessSquare piece;
4893     ChessMove moveType;
4894     Boolean premove;
4895
4896     if(fromX < BOARD_LEFT || fromX >= BOARD_RGHT) return FALSE; // drop
4897     if(toX   < BOARD_LEFT || toX   >= BOARD_RGHT) return FALSE; // move into holdings
4898
4899     if(gameMode == EditPosition || gameInfo.variant == VariantXiangqi || // no promotions
4900       !(fromX >=0 && fromY >= 0 && toX >= 0 && toY >= 0) ) // invalid move
4901         return FALSE;
4902
4903     piece = boards[currentMove][fromY][fromX];
4904     if(gameInfo.variant == VariantShogi) {
4905         promotionZoneSize = 3;
4906         highestPromotingPiece = (int)WhiteFerz;
4907     }
4908
4909     // next weed out all moves that do not touch the promotion zone at all
4910     if((int)piece >= BlackPawn) {
4911         if(toY >= promotionZoneSize && fromY >= promotionZoneSize)
4912              return FALSE;
4913         highestPromotingPiece = WHITE_TO_BLACK highestPromotingPiece;
4914     } else {
4915         if(  toY < BOARD_HEIGHT - promotionZoneSize &&
4916            fromY < BOARD_HEIGHT - promotionZoneSize) return FALSE;
4917     }
4918
4919     if( (int)piece > highestPromotingPiece ) return FALSE; // non-promoting piece
4920
4921     // weed out mandatory Shogi promotions
4922     if(gameInfo.variant == VariantShogi) {
4923         if(piece >= BlackPawn) {
4924             if(toY == 0 && piece == BlackPawn ||
4925                toY == 0 && piece == BlackQueen ||
4926                toY <= 1 && piece == BlackKnight) {
4927                 *promoChoice = '+';
4928                 return FALSE;
4929             }
4930         } else {
4931             if(toY == BOARD_HEIGHT-1 && piece == WhitePawn ||
4932                toY == BOARD_HEIGHT-1 && piece == WhiteQueen ||
4933                toY >= BOARD_HEIGHT-2 && piece == WhiteKnight) {
4934                 *promoChoice = '+';
4935                 return FALSE;
4936             }
4937         }
4938     }
4939
4940     // weed out obviously illegal Pawn moves
4941     if(appData.testLegality  && (piece == WhitePawn || piece == BlackPawn) ) {
4942         if(toX > fromX+1 || toX < fromX-1) return FALSE; // wide
4943         if(piece == WhitePawn && toY != fromY+1) return FALSE; // deep
4944         if(piece == BlackPawn && toY != fromY-1) return FALSE; // deep
4945         if(fromX != toX && gameInfo.variant == VariantShogi) return FALSE;
4946         // note we are not allowed to test for valid (non-)capture, due to premove
4947     }
4948
4949     // we either have a choice what to promote to, or (in Shogi) whether to promote
4950     if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier) {
4951         *promoChoice = PieceToChar(BlackFerz);  // no choice
4952         return FALSE;
4953     }
4954     if(appData.alwaysPromoteToQueen) { // predetermined
4955         if(gameInfo.variant == VariantSuicide || gameInfo.variant == VariantLosers)
4956              *promoChoice = PieceToChar(BlackKing); // in Suicide Q is the last thing we want
4957         else *promoChoice = PieceToChar(BlackQueen);
4958         return FALSE;
4959     }
4960
4961     // suppress promotion popup on illegal moves that are not premoves
4962     premove = gameMode == IcsPlayingWhite && !WhiteOnMove(currentMove) ||
4963               gameMode == IcsPlayingBlack &&  WhiteOnMove(currentMove);
4964     if(appData.testLegality && !premove) {
4965         moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
4966                         epStatus[currentMove], castlingRights[currentMove],
4967                         fromY, fromX, toY, toX, NULLCHAR);
4968         if(moveType != WhitePromotionQueen && moveType  != BlackPromotionQueen &&
4969            moveType != WhitePromotionKnight && moveType != BlackPromotionKnight)
4970             return FALSE;
4971     }
4972
4973     return TRUE;
4974 }
4975
4976 int
4977 InPalace(row, column)
4978      int row, column;
4979 {   /* [HGM] for Xiangqi */
4980     if( (row < 3 || row > BOARD_HEIGHT-4) &&
4981          column < (BOARD_WIDTH + 4)/2 &&
4982          column > (BOARD_WIDTH - 5)/2 ) return TRUE;
4983     return FALSE;
4984 }
4985
4986 int
4987 PieceForSquare (x, y)
4988      int x;
4989      int y;
4990 {
4991   if (x < 0 || x >= BOARD_WIDTH || y < 0 || y >= BOARD_HEIGHT)
4992      return -1;
4993   else
4994      return boards[currentMove][y][x];
4995 }
4996
4997 int
4998 OKToStartUserMove(x, y)
4999      int x, y;
5000 {
5001     ChessSquare from_piece;
5002     int white_piece;
5003
5004     if (matchMode) return FALSE;
5005     if (gameMode == EditPosition) return TRUE;
5006
5007     if (x >= 0 && y >= 0)
5008       from_piece = boards[currentMove][y][x];
5009     else
5010       from_piece = EmptySquare;
5011
5012     if (from_piece == EmptySquare) return FALSE;
5013
5014     white_piece = (int)from_piece >= (int)WhitePawn &&
5015       (int)from_piece < (int)BlackPawn; /* [HGM] can be > King! */
5016
5017     switch (gameMode) {
5018       case PlayFromGameFile:
5019       case AnalyzeFile:
5020       case TwoMachinesPlay:
5021       case EndOfGame:
5022         return FALSE;
5023
5024       case IcsObserving:
5025       case IcsIdle:
5026         return FALSE;
5027
5028       case MachinePlaysWhite:
5029       case IcsPlayingBlack:
5030         if (appData.zippyPlay) return FALSE;
5031         if (white_piece) {
5032             DisplayMoveError(_("You are playing Black"));
5033             return FALSE;
5034         }
5035         break;
5036
5037       case MachinePlaysBlack:
5038       case IcsPlayingWhite:
5039         if (appData.zippyPlay) return FALSE;
5040         if (!white_piece) {
5041             DisplayMoveError(_("You are playing White"));
5042             return FALSE;
5043         }
5044         break;
5045
5046       case EditGame:
5047         if (!white_piece && WhiteOnMove(currentMove)) {
5048             DisplayMoveError(_("It is White's turn"));
5049             return FALSE;
5050         }
5051         if (white_piece && !WhiteOnMove(currentMove)) {
5052             DisplayMoveError(_("It is Black's turn"));
5053             return FALSE;
5054         }
5055         if (cmailMsgLoaded && (currentMove < cmailOldMove)) {
5056             /* Editing correspondence game history */
5057             /* Could disallow this or prompt for confirmation */
5058             cmailOldMove = -1;
5059         }
5060         if (currentMove < forwardMostMove) {
5061             /* Discarding moves */
5062             /* Could prompt for confirmation here,
5063                but I don't think that's such a good idea */
5064             forwardMostMove = currentMove;
5065         }
5066         break;
5067
5068       case BeginningOfGame:
5069         if (appData.icsActive) return FALSE;
5070         if (!appData.noChessProgram) {
5071             if (!white_piece) {
5072                 DisplayMoveError(_("You are playing White"));
5073                 return FALSE;
5074             }
5075         }
5076         break;
5077
5078       case Training:
5079         if (!white_piece && WhiteOnMove(currentMove)) {
5080             DisplayMoveError(_("It is White's turn"));
5081             return FALSE;
5082         }
5083         if (white_piece && !WhiteOnMove(currentMove)) {
5084             DisplayMoveError(_("It is Black's turn"));
5085             return FALSE;
5086         }
5087         break;
5088
5089       default:
5090       case IcsExamining:
5091         break;
5092     }
5093     if (currentMove != forwardMostMove && gameMode != AnalyzeMode
5094         && gameMode != AnalyzeFile && gameMode != Training) {
5095         DisplayMoveError(_("Displayed position is not current"));
5096         return FALSE;
5097     }
5098     return TRUE;
5099 }
5100
5101 FILE *lastLoadGameFP = NULL, *lastLoadPositionFP = NULL;
5102 int lastLoadGameNumber = 0, lastLoadPositionNumber = 0;
5103 int lastLoadGameUseList = FALSE;
5104 char lastLoadGameTitle[MSG_SIZ], lastLoadPositionTitle[MSG_SIZ];
5105 ChessMove lastLoadGameStart = (ChessMove) 0;
5106
5107 ChessMove
5108 UserMoveTest(fromX, fromY, toX, toY, promoChar, captureOwn)
5109      int fromX, fromY, toX, toY;
5110      int promoChar;
5111      Boolean captureOwn;
5112 {
5113     ChessMove moveType;
5114     ChessSquare pdown, pup;
5115
5116     /* Check if the user is playing in turn.  This is complicated because we
5117        let the user "pick up" a piece before it is his turn.  So the piece he
5118        tried to pick up may have been captured by the time he puts it down!
5119        Therefore we use the color the user is supposed to be playing in this
5120        test, not the color of the piece that is currently on the starting
5121        square---except in EditGame mode, where the user is playing both
5122        sides; fortunately there the capture race can't happen.  (It can
5123        now happen in IcsExamining mode, but that's just too bad.  The user
5124        will get a somewhat confusing message in that case.)
5125        */
5126
5127     switch (gameMode) {
5128       case PlayFromGameFile:
5129       case AnalyzeFile:
5130       case TwoMachinesPlay:
5131       case EndOfGame:
5132       case IcsObserving:
5133       case IcsIdle:
5134         /* We switched into a game mode where moves are not accepted,
5135            perhaps while the mouse button was down. */
5136         return ImpossibleMove;
5137
5138       case MachinePlaysWhite:
5139         /* User is moving for Black */
5140         if (WhiteOnMove(currentMove)) {
5141             DisplayMoveError(_("It is White's turn"));
5142             return ImpossibleMove;
5143         }
5144         break;
5145
5146       case MachinePlaysBlack:
5147         /* User is moving for White */
5148         if (!WhiteOnMove(currentMove)) {
5149             DisplayMoveError(_("It is Black's turn"));
5150             return ImpossibleMove;
5151         }
5152         break;
5153
5154       case EditGame:
5155       case IcsExamining:
5156       case BeginningOfGame:
5157       case AnalyzeMode:
5158       case Training:
5159         if ((int) boards[currentMove][fromY][fromX] >= (int) BlackPawn &&
5160             (int) boards[currentMove][fromY][fromX] < (int) EmptySquare) {
5161             /* User is moving for Black */
5162             if (WhiteOnMove(currentMove)) {
5163                 DisplayMoveError(_("It is White's turn"));
5164                 return ImpossibleMove;
5165             }
5166         } else {
5167             /* User is moving for White */
5168             if (!WhiteOnMove(currentMove)) {
5169                 DisplayMoveError(_("It is Black's turn"));
5170                 return ImpossibleMove;
5171             }
5172         }
5173         break;
5174
5175       case IcsPlayingBlack:
5176         /* User is moving for Black */
5177         if (WhiteOnMove(currentMove)) {
5178             if (!appData.premove) {
5179                 DisplayMoveError(_("It is White's turn"));
5180             } else if (toX >= 0 && toY >= 0) {
5181                 premoveToX = toX;
5182                 premoveToY = toY;
5183                 premoveFromX = fromX;
5184                 premoveFromY = fromY;
5185                 premovePromoChar = promoChar;
5186                 gotPremove = 1;
5187                 if (appData.debugMode)
5188                     fprintf(debugFP, "Got premove: fromX %d,"
5189                             "fromY %d, toX %d, toY %d\n",
5190                             fromX, fromY, toX, toY);
5191             }
5192             return ImpossibleMove;
5193         }
5194         break;
5195
5196       case IcsPlayingWhite:
5197         /* User is moving for White */
5198         if (!WhiteOnMove(currentMove)) {
5199             if (!appData.premove) {
5200                 DisplayMoveError(_("It is Black's turn"));
5201             } else if (toX >= 0 && toY >= 0) {
5202                 premoveToX = toX;
5203                 premoveToY = toY;
5204                 premoveFromX = fromX;
5205                 premoveFromY = fromY;
5206                 premovePromoChar = promoChar;
5207                 gotPremove = 1;
5208                 if (appData.debugMode)
5209                     fprintf(debugFP, "Got premove: fromX %d,"
5210                             "fromY %d, toX %d, toY %d\n",
5211                             fromX, fromY, toX, toY);
5212             }
5213             return ImpossibleMove;
5214         }
5215         break;
5216
5217       default:
5218         break;
5219
5220       case EditPosition:
5221         /* EditPosition, empty square, or different color piece;
5222            click-click move is possible */
5223         if (toX == -2 || toY == -2) {
5224             boards[0][fromY][fromX] = EmptySquare;
5225             return AmbiguousMove;
5226         } else if (toX >= 0 && toY >= 0) {
5227             boards[0][toY][toX] = boards[0][fromY][fromX];
5228             boards[0][fromY][fromX] = EmptySquare;
5229             return AmbiguousMove;
5230         }
5231         return ImpossibleMove;
5232     }
5233
5234     pdown = boards[currentMove][fromY][fromX];
5235     pup = boards[currentMove][toY][toX];
5236
5237     /* [HGM] If move started in holdings, it means a drop */
5238     if( fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) {
5239          if( pup != EmptySquare ) return ImpossibleMove;
5240          if(appData.testLegality) {
5241              /* it would be more logical if LegalityTest() also figured out
5242               * which drops are legal. For now we forbid pawns on back rank.
5243               * Shogi is on its own here...
5244               */
5245              if( (pdown == WhitePawn || pdown == BlackPawn) &&
5246                  (toY == 0 || toY == BOARD_HEIGHT -1 ) )
5247                  return(ImpossibleMove); /* no pawn drops on 1st/8th */
5248          }
5249          return WhiteDrop; /* Not needed to specify white or black yet */
5250     }
5251
5252     userOfferedDraw = FALSE;
5253
5254     /* [HGM] always test for legality, to get promotion info */
5255     moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
5256                           epStatus[currentMove], castlingRights[currentMove],
5257                                          fromY, fromX, toY, toX, promoChar);
5258     /* [HGM] but possibly ignore an IllegalMove result */
5259     if (appData.testLegality) {
5260         if (moveType == IllegalMove || moveType == ImpossibleMove) {
5261             DisplayMoveError(_("Illegal move"));
5262             return ImpossibleMove;
5263         }
5264     }
5265 if(appData.debugMode) fprintf(debugFP, "moveType 3 = %d, promochar = %x\n", moveType, promoChar);
5266     return moveType;
5267     /* [HGM] <popupFix> in stead of calling FinishMove directly, this
5268        function is made into one that returns an OK move type if FinishMove
5269        should be called. This to give the calling driver routine the
5270        opportunity to finish the userMove input with a promotion popup,
5271        without bothering the user with this for invalid or illegal moves */
5272
5273 /*    FinishMove(moveType, fromX, fromY, toX, toY, promoChar); */
5274 }
5275
5276 /* Common tail of UserMoveEvent and DropMenuEvent */
5277 int
5278 FinishMove(moveType, fromX, fromY, toX, toY, promoChar)
5279      ChessMove moveType;
5280      int fromX, fromY, toX, toY;
5281      /*char*/int promoChar;
5282 {
5283     char *bookHit = 0;
5284 if(appData.debugMode) fprintf(debugFP, "moveType 5 = %d, promochar = %x\n", moveType, promoChar);
5285     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) && promoChar != NULLCHAR) {
5286         // [HGM] superchess: suppress promotions to non-available piece
5287         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
5288         if(WhiteOnMove(currentMove)) {
5289             if(!boards[currentMove][k][BOARD_WIDTH-2]) return 0;
5290         } else {
5291             if(!boards[currentMove][BOARD_HEIGHT-1-k][1]) return 0;
5292         }
5293     }
5294
5295     /* [HGM] <popupFix> kludge to avoid having to know the exact promotion
5296        move type in caller when we know the move is a legal promotion */
5297     if(moveType == NormalMove && promoChar)
5298         moveType = PromoCharToMoveType(WhiteOnMove(currentMove), promoChar);
5299 if(appData.debugMode) fprintf(debugFP, "moveType 1 = %d, promochar = %x\n", moveType, promoChar);
5300     /* [HGM] convert drag-and-drop piece drops to standard form */
5301     if( fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) {
5302          moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
5303            if(appData.debugMode) fprintf(debugFP, "Drop move %d, curr=%d, x=%d,y=%d, p=%d\n",
5304                 moveType, currentMove, fromX, fromY, boards[currentMove][fromY][fromX]);
5305 //         fromX = boards[currentMove][fromY][fromX];
5306            // holdings might not be sent yet in ICS play; we have to figure out which piece belongs here
5307            if(fromX == 0) fromY = BOARD_HEIGHT-1 - fromY; // black holdings upside-down
5308            fromX = fromX ? WhitePawn : BlackPawn; // first piece type in selected holdings
5309            while(PieceToChar(fromX) == '.' || PieceToNumber(fromX) != fromY && fromX != (int) EmptySquare) fromX++;
5310          fromY = DROP_RANK;
5311     }
5312
5313     /* [HGM] <popupFix> The following if has been moved here from
5314        UserMoveEvent(). Because it seemed to belon here (why not allow
5315        piece drops in training games?), and because it can only be
5316        performed after it is known to what we promote. */
5317     if (gameMode == Training) {
5318       /* compare the move played on the board to the next move in the
5319        * game. If they match, display the move and the opponent's response.
5320        * If they don't match, display an error message.
5321        */
5322       int saveAnimate;
5323       Board testBoard; char testRights[BOARD_SIZE]; char testStatus;
5324       CopyBoard(testBoard, boards[currentMove]);
5325       ApplyMove(fromX, fromY, toX, toY, promoChar, testBoard, testRights, &testStatus);
5326
5327       if (CompareBoards(testBoard, boards[currentMove+1])) {
5328         ForwardInner(currentMove+1);
5329
5330         /* Autoplay the opponent's response.
5331          * if appData.animate was TRUE when Training mode was entered,
5332          * the response will be animated.
5333          */
5334         saveAnimate = appData.animate;
5335         appData.animate = animateTraining;
5336         ForwardInner(currentMove+1);
5337         appData.animate = saveAnimate;
5338
5339         /* check for the end of the game */
5340         if (currentMove >= forwardMostMove) {
5341           gameMode = PlayFromGameFile;
5342           ModeHighlight();
5343           SetTrainingModeOff();
5344           DisplayInformation(_("End of game"));
5345         }
5346       } else {
5347         DisplayError(_("Incorrect move"), 0);
5348       }
5349       return 1;
5350     }
5351
5352   /* Ok, now we know that the move is good, so we can kill
5353      the previous line in Analysis Mode */
5354   if (gameMode == AnalyzeMode && currentMove < forwardMostMove) {
5355     forwardMostMove = currentMove;
5356   }
5357
5358   /* If we need the chess program but it's dead, restart it */
5359   ResurrectChessProgram();
5360
5361   /* A user move restarts a paused game*/
5362   if (pausing)
5363     PauseEvent();
5364
5365   thinkOutput[0] = NULLCHAR;
5366
5367   MakeMove(fromX, fromY, toX, toY, promoChar); /*updates forwardMostMove*/
5368
5369   if (gameMode == BeginningOfGame) {
5370     if (appData.noChessProgram) {
5371       gameMode = EditGame;
5372       SetGameInfo();
5373     } else {
5374       char buf[MSG_SIZ];
5375       gameMode = MachinePlaysBlack;
5376       StartClocks();
5377       SetGameInfo();
5378       sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
5379       DisplayTitle(buf);
5380       if (first.sendName) {
5381         sprintf(buf, "name %s\n", gameInfo.white);
5382         SendToProgram(buf, &first);
5383       }
5384       StartClocks();
5385     }
5386     ModeHighlight();
5387   }
5388 if(appData.debugMode) fprintf(debugFP, "moveType 2 = %d, promochar = %x\n", moveType, promoChar);
5389   /* Relay move to ICS or chess engine */
5390   if (appData.icsActive) {
5391     if (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
5392         gameMode == IcsExamining) {
5393       SendMoveToICS(moveType, fromX, fromY, toX, toY);
5394       ics_user_moved = 1;
5395     }
5396   } else {
5397     if (first.sendTime && (gameMode == BeginningOfGame ||
5398                            gameMode == MachinePlaysWhite ||
5399                            gameMode == MachinePlaysBlack)) {
5400       SendTimeRemaining(&first, gameMode != MachinePlaysBlack);
5401     }
5402     if (gameMode != EditGame && gameMode != PlayFromGameFile) {
5403          // [HGM] book: if program might be playing, let it use book
5404         bookHit = SendMoveToBookUser(forwardMostMove-1, &first, FALSE);
5405         first.maybeThinking = TRUE;
5406     } else SendMoveToProgram(forwardMostMove-1, &first);
5407     if (currentMove == cmailOldMove + 1) {
5408       cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
5409     }
5410   }
5411
5412   ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
5413
5414   switch (gameMode) {
5415   case EditGame:
5416     switch (MateTest(boards[currentMove], PosFlags(currentMove),
5417                      EP_UNKNOWN, castlingRights[currentMove]) ) {
5418     case MT_NONE:
5419     case MT_CHECK:
5420       break;
5421     case MT_CHECKMATE:
5422     case MT_STAINMATE:
5423       if (WhiteOnMove(currentMove)) {
5424         GameEnds(BlackWins, "Black mates", GE_PLAYER);
5425       } else {
5426         GameEnds(WhiteWins, "White mates", GE_PLAYER);
5427       }
5428       break;
5429     case MT_STALEMATE:
5430       GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
5431       break;
5432     }
5433     break;
5434
5435   case MachinePlaysBlack:
5436   case MachinePlaysWhite:
5437     /* disable certain menu options while machine is thinking */
5438     SetMachineThinkingEnables();
5439     break;
5440
5441   default:
5442     break;
5443   }
5444
5445   if(bookHit) { // [HGM] book: simulate book reply
5446         static char bookMove[MSG_SIZ]; // a bit generous?
5447
5448         programStats.nodes = programStats.depth = programStats.time =
5449         programStats.score = programStats.got_only_move = 0;
5450         sprintf(programStats.movelist, "%s (xbook)", bookHit);
5451
5452         strcpy(bookMove, "move ");
5453         strcat(bookMove, bookHit);
5454         HandleMachineMove(bookMove, &first);
5455   }
5456   return 1;
5457 }
5458
5459 void
5460 UserMoveEvent(fromX, fromY, toX, toY, promoChar)
5461      int fromX, fromY, toX, toY;
5462      int promoChar;
5463 {
5464     /* [HGM] This routine was added to allow calling of its two logical
5465        parts from other modules in the old way. Before, UserMoveEvent()
5466        automatically called FinishMove() if the move was OK, and returned
5467        otherwise. I separated the two, in order to make it possible to
5468        slip a promotion popup in between. But that it always needs two
5469        calls, to the first part, (now called UserMoveTest() ), and to
5470        FinishMove if the first part succeeded. Calls that do not need
5471        to do anything in between, can call this routine the old way.
5472     */
5473     ChessMove moveType = UserMoveTest(fromX, fromY, toX, toY, promoChar, FALSE);
5474 if(appData.debugMode) fprintf(debugFP, "moveType 4 = %d, promochar = %x\n", moveType, promoChar);
5475     if(moveType == AmbiguousMove)
5476         DrawPosition(FALSE, boards[currentMove]);
5477     else if(moveType != ImpossibleMove && moveType != Comment)
5478         FinishMove(moveType, fromX, fromY, toX, toY, promoChar);
5479 }
5480
5481 void LeftClick(ClickType clickType, int xPix, int yPix)
5482 {
5483     int x, y;
5484     Boolean saveAnimate;
5485     static int second = 0, promotionChoice = 0;
5486     char promoChoice = NULLCHAR;
5487
5488     if (clickType == Press) ErrorPopDown();
5489
5490     x = EventToSquare(xPix, BOARD_WIDTH);
5491     y = EventToSquare(yPix, BOARD_HEIGHT);
5492     if (!flipView && y >= 0) {
5493         y = BOARD_HEIGHT - 1 - y;
5494     }
5495     if (flipView && x >= 0) {
5496         x = BOARD_WIDTH - 1 - x;
5497     }
5498
5499     if(promotionChoice) { // we are waiting for a click to indicate promotion piece
5500         if(clickType == Release) return; // ignore upclick of click-click destination
5501         promotionChoice = FALSE; // only one chance: if click not OK it is interpreted as cancel
5502         if(appData.debugMode) fprintf(debugFP, "promotion click, x=%d, y=%d\n", x, y);
5503         if(gameInfo.holdingsWidth &&
5504                 (WhiteOnMove(currentMove)
5505                         ? x == BOARD_WIDTH-1 && y < gameInfo.holdingsSize && y > 0
5506                         : x == 0 && y >= BOARD_HEIGHT - gameInfo.holdingsSize && y < BOARD_HEIGHT-1) ) {
5507             // click in right holdings, for determining promotion piece
5508             ChessSquare p = boards[currentMove][y][x];
5509             if(appData.debugMode) fprintf(debugFP, "square contains %d\n", (int)p);
5510             if(p != EmptySquare) {
5511                 FinishMove(NormalMove, fromX, fromY, toX, toY, ToLower(PieceToChar(p)));
5512                 fromX = fromY = -1;
5513                 return;
5514             }
5515         }
5516         DrawPosition(FALSE, boards[currentMove]);
5517         return;
5518     }
5519
5520     /* [HGM] holdings: next 5 lines: ignore all clicks between board and holdings */
5521     if(clickType == Press
5522             && ( x == BOARD_LEFT-1 || x == BOARD_RGHT
5523               || x == BOARD_LEFT-2 && y < BOARD_HEIGHT-gameInfo.holdingsSize
5524               || x == BOARD_RGHT+1 && y >= gameInfo.holdingsSize) )
5525         return;
5526
5527     if (fromX == -1) {
5528         if (clickType == Press) {
5529             /* First square */
5530             if (OKToStartUserMove(x, y)) {
5531                 fromX = x;
5532                 fromY = y;
5533                 second = 0;
5534                 DragPieceBegin(xPix, yPix);
5535                 if (appData.highlightDragging) {
5536                     SetHighlights(x, y, -1, -1);
5537                 }
5538             }
5539         }
5540         return;
5541     }
5542
5543     /* fromX != -1 */
5544     if (clickType == Press && gameMode != EditPosition) {
5545         ChessSquare fromP;
5546         ChessSquare toP;
5547         int frc;
5548
5549         // ignore off-board to clicks
5550         if(y < 0 || x < 0) return;
5551
5552         /* Check if clicking again on the same color piece */
5553         fromP = boards[currentMove][fromY][fromX];
5554         toP = boards[currentMove][y][x];
5555         frc = gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom;
5556         if ((WhitePawn <= fromP && fromP <= WhiteKing &&
5557              WhitePawn <= toP && toP <= WhiteKing &&
5558              !(fromP == WhiteKing && toP == WhiteRook && frc) &&
5559              !(fromP == WhiteRook && toP == WhiteKing && frc)) ||
5560             (BlackPawn <= fromP && fromP <= BlackKing &&
5561              BlackPawn <= toP && toP <= BlackKing &&
5562              !(fromP == BlackRook && toP == BlackKing && frc) && // allow also RxK as FRC castling
5563              !(fromP == BlackKing && toP == BlackRook && frc))) {
5564             /* Clicked again on same color piece -- changed his mind */
5565             second = (x == fromX && y == fromY);
5566             if (appData.highlightDragging) {
5567                 SetHighlights(x, y, -1, -1);
5568             } else {
5569                 ClearHighlights();
5570             }
5571             if (OKToStartUserMove(x, y)) {
5572                 fromX = x;
5573                 fromY = y;
5574                 DragPieceBegin(xPix, yPix);
5575             }
5576             return;
5577         }
5578         // ignore to-clicks in holdings
5579         if(x < BOARD_LEFT || x >= BOARD_RGHT) return;
5580     }
5581
5582     if (clickType == Release && (x == fromX && y == fromY ||
5583         x < BOARD_LEFT || x >= BOARD_RGHT)) {
5584
5585         // treat drags into holding as click on start square
5586         x = fromX; y = fromY;
5587
5588         DragPieceEnd(xPix, yPix);
5589         if (appData.animateDragging) {
5590             /* Undo animation damage if any */
5591             DrawPosition(FALSE, NULL);
5592         }
5593         if (second) {
5594             /* Second up/down in same square; just abort move */
5595             second = 0;
5596             fromX = fromY = -1;
5597             ClearHighlights();
5598             gotPremove = 0;
5599             ClearPremoveHighlights();
5600         } else {
5601             /* First upclick in same square; start click-click mode */
5602             SetHighlights(x, y, -1, -1);
5603         }
5604         return;
5605     }
5606
5607     /* we now have a different from- and to-square */
5608     /* Completed move */
5609     toX = x;
5610     toY = y;
5611     saveAnimate = appData.animate;
5612     if (clickType == Press) {
5613         /* Finish clickclick move */
5614         if (appData.animate || appData.highlightLastMove) {
5615             SetHighlights(fromX, fromY, toX, toY);
5616         } else {
5617             ClearHighlights();
5618         }
5619     } else {
5620         /* Finish drag move */
5621         if (appData.highlightLastMove) {
5622             SetHighlights(fromX, fromY, toX, toY);
5623         } else {
5624             ClearHighlights();
5625         }
5626         DragPieceEnd(xPix, yPix);
5627         /* Don't animate move and drag both */
5628         appData.animate = FALSE;
5629     }
5630     if (HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice)) {
5631         SetHighlights(fromX, fromY, toX, toY);
5632         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
5633             // [HGM] super: promotion to captured piece selected from holdings
5634             ChessSquare p = boards[currentMove][fromY][fromX], q = boards[currentMove][toY][toX];
5635             promotionChoice = TRUE;
5636             // kludge follows to temporarily execute move on display, without promoting yet
5637             boards[currentMove][fromY][fromX] = EmptySquare; // move Pawn to 8th rank
5638             boards[currentMove][toY][toX] = p;
5639             DrawPosition(FALSE, boards[currentMove]);
5640             boards[currentMove][fromY][fromX] = p; // take back, but display stays
5641             boards[currentMove][toY][toX] = q;
5642             DisplayMessage("Click in holdings to choose piece", "");
5643             return;
5644         }
5645         PromotionPopUp();
5646     } else {
5647         UserMoveEvent(fromX, fromY, toX, toY, promoChoice);
5648         if (!appData.highlightLastMove || gotPremove) ClearHighlights();
5649         if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
5650         fromX = fromY = -1;
5651     }
5652     appData.animate = saveAnimate;
5653     if (appData.animate || appData.animateDragging) {
5654         /* Undo animation damage if needed */
5655         DrawPosition(FALSE, NULL);
5656     }
5657 }
5658
5659 void SendProgramStatsToFrontend( ChessProgramState * cps, ChessProgramStats * cpstats )
5660 {
5661 //    char * hint = lastHint;
5662     FrontEndProgramStats stats;
5663
5664     stats.which = cps == &first ? 0 : 1;
5665     stats.depth = cpstats->depth;
5666     stats.nodes = cpstats->nodes;
5667     stats.score = cpstats->score;
5668     stats.time = cpstats->time;
5669     stats.pv = cpstats->movelist;
5670     stats.hint = lastHint;
5671     stats.an_move_index = 0;
5672     stats.an_move_count = 0;
5673
5674     if( gameMode == AnalyzeMode || gameMode == AnalyzeFile ) {
5675         stats.hint = cpstats->move_name;
5676         stats.an_move_index = cpstats->nr_moves - cpstats->moves_left;
5677         stats.an_move_count = cpstats->nr_moves;
5678     }
5679
5680     SetProgramStats( &stats );
5681 }
5682
5683 char *SendMoveToBookUser(int moveNr, ChessProgramState *cps, int initial)
5684 {   // [HGM] book: this routine intercepts moves to simulate book replies
5685     char *bookHit = NULL;
5686
5687     //first determine if the incoming move brings opponent into his book
5688     if(appData.usePolyglotBook && (cps == &first ? !appData.firstHasOwnBookUCI : !appData.secondHasOwnBookUCI))
5689         bookHit = ProbeBook(moveNr+1, appData.polyglotBook); // returns move
5690     if(appData.debugMode) fprintf(debugFP, "book hit = %s\n", bookHit ? bookHit : "(NULL)");
5691     if(bookHit != NULL && !cps->bookSuspend) {
5692         // make sure opponent is not going to reply after receiving move to book position
5693         SendToProgram("force\n", cps);
5694         cps->bookSuspend = TRUE; // flag indicating it has to be restarted
5695     }
5696     if(!initial) SendMoveToProgram(moveNr, cps); // with hit on initial position there is no move
5697     // now arrange restart after book miss
5698     if(bookHit) {
5699         // after a book hit we never send 'go', and the code after the call to this routine
5700         // has '&& !bookHit' added to suppress potential sending there (based on 'firstMove').
5701         char buf[MSG_SIZ];
5702         if (cps->useUsermove) sprintf(buf, "usermove "); // sorry, no SAN yet :(
5703         sprintf(buf, "%s\n", bookHit); // force book move into program supposed to play it
5704         SendToProgram(buf, cps);
5705         if(!initial) firstMove = FALSE; // normally we would clear the firstMove condition after return & sending 'go'
5706     } else if(initial) { // 'go' was needed irrespective of firstMove, and it has to be done in this routine
5707         SendToProgram("go\n", cps);
5708         cps->bookSuspend = FALSE; // after a 'go' we are never suspended
5709     } else { // 'go' might be sent based on 'firstMove' after this routine returns
5710         if(cps->bookSuspend && !firstMove) // 'go' needed, and it will not be done after we return
5711             SendToProgram("go\n", cps);
5712         cps->bookSuspend = FALSE; // anyhow, we will not be suspended after a miss
5713     }
5714     return bookHit; // notify caller of hit, so it can take action to send move to opponent
5715 }
5716
5717 char *savedMessage;
5718 ChessProgramState *savedState;
5719 void DeferredBookMove(void)
5720 {
5721         if(savedState->lastPing != savedState->lastPong)
5722                     ScheduleDelayedEvent(DeferredBookMove, 10);
5723         else
5724         HandleMachineMove(savedMessage, savedState);
5725 }
5726
5727 void
5728 HandleMachineMove(message, cps)
5729      char *message;
5730      ChessProgramState *cps;
5731 {
5732     char machineMove[MSG_SIZ], buf1[MSG_SIZ*10], buf2[MSG_SIZ];
5733     char realname[MSG_SIZ];
5734     int fromX, fromY, toX, toY;
5735     ChessMove moveType;
5736     char promoChar;
5737     char *p;
5738     int machineWhite;
5739     char *bookHit;
5740
5741 FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book hit
5742     /*
5743      * Kludge to ignore BEL characters
5744      */
5745     while (*message == '\007') message++;
5746
5747     /*
5748      * [HGM] engine debug message: ignore lines starting with '#' character
5749      */
5750     if(cps->debug && *message == '#') return;
5751
5752     /*
5753      * Look for book output
5754      */
5755     if (cps == &first && bookRequested) {
5756         if (message[0] == '\t' || message[0] == ' ') {
5757             /* Part of the book output is here; append it */
5758             strcat(bookOutput, message);
5759             strcat(bookOutput, "  \n");
5760             return;
5761         } else if (bookOutput[0] != NULLCHAR) {
5762             /* All of book output has arrived; display it */
5763             char *p = bookOutput;
5764             while (*p != NULLCHAR) {
5765                 if (*p == '\t') *p = ' ';
5766                 p++;
5767             }
5768             DisplayInformation(bookOutput);
5769             bookRequested = FALSE;
5770             /* Fall through to parse the current output */
5771         }
5772     }
5773
5774     /*
5775      * Look for machine move.
5776      */
5777     if ((sscanf(message, "%s %s %s", buf1, buf2, machineMove) == 3 && strcmp(buf2, "...") == 0) ||
5778         (sscanf(message, "%s %s", buf1, machineMove) == 2 && strcmp(buf1, "move") == 0))
5779     {
5780         /* This method is only useful on engines that support ping */
5781         if (cps->lastPing != cps->lastPong) {
5782           if (gameMode == BeginningOfGame) {
5783             /* Extra move from before last new; ignore */
5784             if (appData.debugMode) {
5785                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
5786             }
5787           } else {
5788             if (appData.debugMode) {
5789                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
5790                         cps->which, gameMode);
5791             }
5792
5793             SendToProgram("undo\n", cps);
5794           }
5795           return;
5796         }
5797
5798         switch (gameMode) {
5799           case BeginningOfGame:
5800             /* Extra move from before last reset; ignore */
5801             if (appData.debugMode) {
5802                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
5803             }
5804             return;
5805
5806           case EndOfGame:
5807           case IcsIdle:
5808           default:
5809             /* Extra move after we tried to stop.  The mode test is
5810                not a reliable way of detecting this problem, but it's
5811                the best we can do on engines that don't support ping.
5812             */
5813             if (appData.debugMode) {
5814                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
5815                         cps->which, gameMode);
5816             }
5817             SendToProgram("undo\n", cps);
5818             return;
5819
5820           case MachinePlaysWhite:
5821           case IcsPlayingWhite:
5822             machineWhite = TRUE;
5823             break;
5824
5825           case MachinePlaysBlack:
5826           case IcsPlayingBlack:
5827             machineWhite = FALSE;
5828             break;
5829
5830           case TwoMachinesPlay:
5831             machineWhite = (cps->twoMachinesColor[0] == 'w');
5832             break;
5833         }
5834         if (WhiteOnMove(forwardMostMove) != machineWhite) {
5835             if (appData.debugMode) {
5836                 fprintf(debugFP,
5837                         "Ignoring move out of turn by %s, gameMode %d"
5838                         ", forwardMost %d\n",
5839                         cps->which, gameMode, forwardMostMove);
5840             }
5841             return;
5842         }
5843
5844     if (appData.debugMode) { int f = forwardMostMove;
5845         fprintf(debugFP, "machine move %d, castling = %d %d %d %d %d %d\n", f,
5846                 castlingRights[f][0],castlingRights[f][1],castlingRights[f][2],castlingRights[f][3],castlingRights[f][4],castlingRights[f][5]);
5847     }
5848         if(cps->alphaRank) AlphaRank(machineMove, 4);
5849         if (!ParseOneMove(machineMove, forwardMostMove, &moveType,
5850                               &fromX, &fromY, &toX, &toY, &promoChar)) {
5851             /* Machine move could not be parsed; ignore it. */
5852             sprintf(buf1, _("Illegal move \"%s\" from %s machine"),
5853                     machineMove, cps->which);
5854             DisplayError(buf1, 0);
5855             sprintf(buf1, "Xboard: Forfeit due to invalid move: %s (%c%c%c%c) res=%d",
5856                     machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, moveType);
5857             if (gameMode == TwoMachinesPlay) {
5858               GameEnds(machineWhite ? BlackWins : WhiteWins,
5859                        buf1, GE_XBOARD);
5860             }
5861             return;
5862         }
5863
5864         /* [HGM] Apparently legal, but so far only tested with EP_UNKOWN */
5865         /* So we have to redo legality test with true e.p. status here,  */
5866         /* to make sure an illegal e.p. capture does not slip through,   */
5867         /* to cause a forfeit on a justified illegal-move complaint      */
5868         /* of the opponent.                                              */
5869         if( gameMode==TwoMachinesPlay && appData.testLegality
5870             && fromY != DROP_RANK /* [HGM] temporary; should still add legality test for drops */
5871                                                               ) {
5872            ChessMove moveType;
5873            moveType = LegalityTest(boards[forwardMostMove], PosFlags(forwardMostMove),
5874                         epStatus[forwardMostMove], castlingRights[forwardMostMove],
5875                              fromY, fromX, toY, toX, promoChar);
5876             if (appData.debugMode) {
5877                 int i;
5878                 for(i=0; i< nrCastlingRights; i++) fprintf(debugFP, "(%d,%d) ",
5879                     castlingRights[forwardMostMove][i], castlingRank[i]);
5880                 fprintf(debugFP, "castling rights\n");
5881             }
5882             if(moveType == IllegalMove) {
5883                 sprintf(buf1, "Xboard: Forfeit due to illegal move: %s (%c%c%c%c)%c",
5884                         machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, 0);
5885                 GameEnds(machineWhite ? BlackWins : WhiteWins,
5886                            buf1, GE_XBOARD);
5887                 return;
5888            } else if(gameInfo.variant != VariantFischeRandom && gameInfo.variant != VariantCapaRandom)
5889            /* [HGM] Kludge to handle engines that send FRC-style castling
5890               when they shouldn't (like TSCP-Gothic) */
5891            switch(moveType) {
5892              case WhiteASideCastleFR:
5893              case BlackASideCastleFR:
5894                toX+=2;
5895                currentMoveString[2]++;
5896                break;
5897              case WhiteHSideCastleFR:
5898              case BlackHSideCastleFR:
5899                toX--;
5900                currentMoveString[2]--;
5901                break;
5902              default: ; // nothing to do, but suppresses warning of pedantic compilers
5903            }
5904         }
5905         hintRequested = FALSE;
5906         lastHint[0] = NULLCHAR;
5907         bookRequested = FALSE;
5908         /* Program may be pondering now */
5909         cps->maybeThinking = TRUE;
5910         if (cps->sendTime == 2) cps->sendTime = 1;
5911         if (cps->offeredDraw) cps->offeredDraw--;
5912
5913 #if ZIPPY
5914         if ((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack) &&
5915             first.initDone) {
5916           SendMoveToICS(moveType, fromX, fromY, toX, toY);
5917           ics_user_moved = 1;
5918           if(appData.autoKibitz && !appData.icsEngineAnalyze ) { /* [HGM] kibitz: send most-recent PV info to ICS */
5919                 char buf[3*MSG_SIZ];
5920
5921                 sprintf(buf, "kibitz !!! %+.2f/%d (%.2f sec, %u nodes, %.0f knps) PV=%s\n",
5922                         programStats.score / 100.,
5923                         programStats.depth,
5924                         programStats.time / 100.,
5925                         (unsigned int)programStats.nodes,
5926                         (unsigned int)programStats.nodes / (10*abs(programStats.time) + 1.),
5927                         programStats.movelist);
5928                 SendToICS(buf);
5929 if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.nodes, programStats.nodes);
5930           }
5931         }
5932 #endif
5933         /* currentMoveString is set as a side-effect of ParseOneMove */
5934         strcpy(machineMove, currentMoveString);
5935         strcat(machineMove, "\n");
5936         strcpy(moveList[forwardMostMove], machineMove);
5937
5938         /* [AS] Save move info and clear stats for next move */
5939         pvInfoList[ forwardMostMove ].score = programStats.score;
5940         pvInfoList[ forwardMostMove ].depth = programStats.depth;
5941         pvInfoList[ forwardMostMove ].time =  programStats.time; // [HGM] PGNtime: take time from engine stats
5942         ClearProgramStats();
5943         thinkOutput[0] = NULLCHAR;
5944         hiddenThinkOutputState = 0;
5945
5946         MakeMove(fromX, fromY, toX, toY, promoChar);/*updates forwardMostMove*/
5947
5948         /* [AS] Adjudicate game if needed (note: remember that forwardMostMove now points past the last move) */
5949         if( gameMode == TwoMachinesPlay && adjudicateLossThreshold != 0 && forwardMostMove >= adjudicateLossPlies ) {
5950             int count = 0;
5951
5952             while( count < adjudicateLossPlies ) {
5953                 int score = pvInfoList[ forwardMostMove - count - 1 ].score;
5954
5955                 if( count & 1 ) {
5956                     score = -score; /* Flip score for winning side */
5957                 }
5958
5959                 if( score > adjudicateLossThreshold ) {
5960                     break;
5961                 }
5962
5963                 count++;
5964             }
5965
5966             if( count >= adjudicateLossPlies ) {
5967                 ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
5968
5969                 GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
5970                     "Xboard adjudication",
5971                     GE_XBOARD );
5972
5973                 return;
5974             }
5975         }
5976
5977         if( gameMode == TwoMachinesPlay ) {
5978           // [HGM] some adjudications useful with buggy engines
5979             int k, count = 0, epFile = epStatus[forwardMostMove]; static int bare = 1;
5980           if(gameInfo.holdingsSize == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
5981
5982
5983             if( appData.testLegality )
5984             {   /* [HGM] Some more adjudications for obstinate engines */
5985                 int NrWN=0, NrBN=0, NrWB=0, NrBB=0, NrWR=0, NrBR=0,
5986                     NrWQ=0, NrBQ=0, NrW=0, NrK=0, bishopsColor = 0,
5987                     NrPieces=0, NrPawns=0, PawnAdvance=0, i, j;
5988                 static int moveCount = 6;
5989                 ChessMove result;
5990                 char *reason = NULL;
5991
5992                 /* Count what is on board. */
5993                 for(i=0; i<BOARD_HEIGHT; i++) for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
5994                 {   ChessSquare p = boards[forwardMostMove][i][j];
5995                     int m=i;
5996
5997                     switch((int) p)
5998                     {   /* count B,N,R and other of each side */
5999                         case WhiteKing:
6000                         case BlackKing:
6001                              NrK++; break; // [HGM] atomic: count Kings
6002                         case WhiteKnight:
6003                              NrWN++; break;
6004                         case WhiteBishop:
6005                         case WhiteFerz:    // [HGM] shatranj: kludge to mke it work in shatranj
6006                              bishopsColor |= 1 << ((i^j)&1);
6007                              NrWB++; break;
6008                         case BlackKnight:
6009                              NrBN++; break;
6010                         case BlackBishop:
6011                         case BlackFerz:    // [HGM] shatranj: kludge to mke it work in shatranj
6012                              bishopsColor |= 1 << ((i^j)&1);
6013                              NrBB++; break;
6014                         case WhiteRook:
6015                              NrWR++; break;
6016                         case BlackRook:
6017                              NrBR++; break;
6018                         case WhiteQueen:
6019                              NrWQ++; break;
6020                         case BlackQueen:
6021                              NrBQ++; break;
6022                         case EmptySquare:
6023                              break;
6024                         case BlackPawn:
6025                              m = 7-i;
6026                         case WhitePawn:
6027                              PawnAdvance += m; NrPawns++;
6028                     }
6029                     NrPieces += (p != EmptySquare);
6030                     NrW += ((int)p < (int)BlackPawn);
6031                     if(gameInfo.variant == VariantXiangqi &&
6032                       (p == WhiteFerz || p == WhiteAlfil || p == BlackFerz || p == BlackAlfil)) {
6033                         NrPieces--; // [HGM] XQ: do not count purely defensive pieces
6034                         NrW -= ((int)p < (int)BlackPawn);
6035                     }
6036                 }
6037
6038                 /* Some material-based adjudications that have to be made before stalemate test */
6039                 if(gameInfo.variant == VariantAtomic && NrK < 2) {
6040                     // [HGM] atomic: stm must have lost his King on previous move, as destroying own K is illegal
6041                      epStatus[forwardMostMove] = EP_CHECKMATE; // make claimable as if stm is checkmated
6042                      if(appData.checkMates) {
6043                          SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets move
6044                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6045                          GameEnds( WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins,
6046                                                         "Xboard adjudication: King destroyed", GE_XBOARD );
6047                          return;
6048                      }
6049                 }
6050
6051                 /* Bare King in Shatranj (loses) or Losers (wins) */
6052                 if( NrW == 1 || NrPieces - NrW == 1) {
6053                   if( gameInfo.variant == VariantLosers) { // [HGM] losers: bare King wins (stm must have it first)
6054                      epStatus[forwardMostMove] = EP_WINS;  // mark as win, so it becomes claimable
6055                      if(appData.checkMates) {
6056                          SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets to see move
6057                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6058                          GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
6059                                                         "Xboard adjudication: Bare king", GE_XBOARD );
6060                          return;
6061                      }
6062                   } else
6063                   if( gameInfo.variant == VariantShatranj && --bare < 0)
6064                   {    /* bare King */
6065                         epStatus[forwardMostMove] = EP_WINS; // make claimable as win for stm
6066                         if(appData.checkMates) {
6067                             /* but only adjudicate if adjudication enabled */
6068                             SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets move
6069                             ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6070                             GameEnds( NrW > 1 ? WhiteWins : NrPieces - NrW > 1 ? BlackWins : GameIsDrawn,
6071                                                         "Xboard adjudication: Bare king", GE_XBOARD );
6072                             return;
6073                         }
6074                   }
6075                 } else bare = 1;
6076
6077
6078             // don't wait for engine to announce game end if we can judge ourselves
6079             switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove), epFile,
6080                                        castlingRights[forwardMostMove]) ) {
6081               case MT_CHECK:
6082                 if(gameInfo.variant == Variant3Check) { // [HGM] 3check: when in check, test if 3rd time
6083                     int i, checkCnt = 0;    // (should really be done by making nr of checks part of game state)
6084                     for(i=forwardMostMove-2; i>=backwardMostMove; i-=2) {
6085                         if(MateTest(boards[i], PosFlags(i), epStatus[i], castlingRights[i]) == MT_CHECK)
6086                             checkCnt++;
6087                         if(checkCnt >= 2) {
6088                             reason = "Xboard adjudication: 3rd check";
6089                             epStatus[forwardMostMove] = EP_CHECKMATE;
6090                             break;
6091                         }
6092                     }
6093                 }
6094               case MT_NONE:
6095               default:
6096                 break;
6097               case MT_STALEMATE:
6098               case MT_STAINMATE:
6099                 reason = "Xboard adjudication: Stalemate";
6100                 if(epStatus[forwardMostMove] != EP_CHECKMATE) { // [HGM] don't touch win through baring or K-capt
6101                     epStatus[forwardMostMove] = EP_STALEMATE;   // default result for stalemate is draw
6102                     if(gameInfo.variant == VariantLosers  || gameInfo.variant == VariantGiveaway) // [HGM] losers:
6103                         epStatus[forwardMostMove] = EP_WINS;    // in these variants stalemated is always a win
6104                     else if(gameInfo.variant == VariantSuicide) // in suicide it depends
6105                         epStatus[forwardMostMove] = NrW == NrPieces-NrW ? EP_STALEMATE :
6106                                                    ((NrW < NrPieces-NrW) != WhiteOnMove(forwardMostMove) ?
6107                                                                         EP_CHECKMATE : EP_WINS);
6108                     else if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantXiangqi)
6109                         epStatus[forwardMostMove] = EP_CHECKMATE; // and in these variants being stalemated loses
6110                 }
6111                 break;
6112               case MT_CHECKMATE:
6113                 reason = "Xboard adjudication: Checkmate";
6114                 epStatus[forwardMostMove] = (gameInfo.variant == VariantLosers ? EP_WINS : EP_CHECKMATE);
6115                 break;
6116             }
6117
6118                 switch(i = epStatus[forwardMostMove]) {
6119                     case EP_STALEMATE:
6120                         result = GameIsDrawn; break;
6121                     case EP_CHECKMATE:
6122                         result = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins; break;
6123                     case EP_WINS:
6124                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins; break;
6125                     default:
6126                         result = (ChessMove) 0;
6127                 }
6128                 if(appData.checkMates && result) { // [HGM] mates: adjudicate finished games if requested
6129                     SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6130                     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6131                     GameEnds( result, reason, GE_XBOARD );
6132                     return;
6133                 }
6134
6135                 /* Next absolutely insufficient mating material. */
6136                 if( NrPieces == 2 || gameInfo.variant != VariantXiangqi &&
6137                                      gameInfo.variant != VariantShatranj && // [HGM] baring will remain possible
6138                         (NrPieces == 3 && NrWN+NrBN+NrWB+NrBB == 1 ||
6139                          NrPieces == NrBB+NrWB+2 && bishopsColor != 3)) // [HGM] all Bishops (Ferz!) same color
6140                 {    /* KBK, KNK, KK of KBKB with like Bishops */
6141
6142                      /* always flag draws, for judging claims */
6143                      epStatus[forwardMostMove] = EP_INSUF_DRAW;
6144
6145                      if(appData.materialDraws) {
6146                          /* but only adjudicate them if adjudication enabled */
6147                          SendToProgram("force\n", cps->other); // suppress reply
6148                          SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see last move */
6149                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6150                          GameEnds( GameIsDrawn, "Xboard adjudication: Insufficient mating material", GE_XBOARD );
6151                          return;
6152                      }
6153                 }
6154
6155                 /* Then some trivial draws (only adjudicate, cannot be claimed) */
6156                 if(NrPieces == 4 &&
6157                    (   NrWR == 1 && NrBR == 1 /* KRKR */
6158                    || NrWQ==1 && NrBQ==1     /* KQKQ */
6159                    || NrWN==2 || NrBN==2     /* KNNK */
6160                    || NrWN+NrWB == 1 && NrBN+NrBB == 1 /* KBKN, KBKB, KNKN */
6161                   ) ) {
6162                      if(--moveCount < 0 && appData.trivialDraws)
6163                      {    /* if the first 3 moves do not show a tactical win, declare draw */
6164                           SendToProgram("force\n", cps->other); // suppress reply
6165                           SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6166                           ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6167                           GameEnds( GameIsDrawn, "Xboard adjudication: Trivial draw", GE_XBOARD );
6168                           return;
6169                      }
6170                 } else moveCount = 6;
6171             }
6172           }
6173
6174           if (appData.debugMode) { int i;
6175             fprintf(debugFP, "repeat test fmm=%d bmm=%d ep=%d, reps=%d\n",
6176                     forwardMostMove, backwardMostMove, epStatus[backwardMostMove],
6177                     appData.drawRepeats);
6178             for( i=forwardMostMove; i>=backwardMostMove; i-- )
6179               fprintf(debugFP, "%d ep=%d\n", i, epStatus[i]);
6180
6181           }
6182
6183                 /* Check for rep-draws */
6184                 count = 0;
6185                 for(k = forwardMostMove-2;
6186                     k>=backwardMostMove && k>=forwardMostMove-100 &&
6187                         epStatus[k] < EP_UNKNOWN &&
6188                         epStatus[k+2] <= EP_NONE && epStatus[k+1] <= EP_NONE;
6189                     k-=2)
6190                 {   int rights=0;
6191                     if(CompareBoards(boards[k], boards[forwardMostMove])) {
6192                         /* compare castling rights */
6193                         if( castlingRights[forwardMostMove][2] != castlingRights[k][2] &&
6194                              (castlingRights[k][0] >= 0 || castlingRights[k][1] >= 0) )
6195                                 rights++; /* King lost rights, while rook still had them */
6196                         if( castlingRights[forwardMostMove][2] >= 0 ) { /* king has rights */
6197                             if( castlingRights[forwardMostMove][0] != castlingRights[k][0] ||
6198                                 castlingRights[forwardMostMove][1] != castlingRights[k][1] )
6199                                    rights++; /* but at least one rook lost them */
6200                         }
6201                         if( castlingRights[forwardMostMove][5] != castlingRights[k][5] &&
6202                              (castlingRights[k][3] >= 0 || castlingRights[k][4] >= 0) )
6203                                 rights++;
6204                         if( castlingRights[forwardMostMove][5] >= 0 ) {
6205                             if( castlingRights[forwardMostMove][3] != castlingRights[k][3] ||
6206                                 castlingRights[forwardMostMove][4] != castlingRights[k][4] )
6207                                    rights++;
6208                         }
6209                         if( rights == 0 && ++count > appData.drawRepeats-2
6210                             && appData.drawRepeats > 1) {
6211                              /* adjudicate after user-specified nr of repeats */
6212                              SendToProgram("force\n", cps->other); // suppress reply
6213                              SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6214                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6215                              if(gameInfo.variant == VariantXiangqi && appData.testLegality) {
6216                                 // [HGM] xiangqi: check for forbidden perpetuals
6217                                 int m, ourPerpetual = 1, hisPerpetual = 1;
6218                                 for(m=forwardMostMove; m>k; m-=2) {
6219                                     if(MateTest(boards[m], PosFlags(m),
6220                                                         EP_NONE, castlingRights[m]) != MT_CHECK)
6221                                         ourPerpetual = 0; // the current mover did not always check
6222                                     if(MateTest(boards[m-1], PosFlags(m-1),
6223                                                         EP_NONE, castlingRights[m-1]) != MT_CHECK)
6224                                         hisPerpetual = 0; // the opponent did not always check
6225                                 }
6226                                 if(appData.debugMode) fprintf(debugFP, "XQ perpetual test, our=%d, his=%d\n",
6227                                                                         ourPerpetual, hisPerpetual);
6228                                 if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit
6229                                     GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
6230                                            "Xboard adjudication: perpetual checking", GE_XBOARD );
6231                                     return;
6232                                 }
6233                                 if(hisPerpetual && !ourPerpetual)   // he is checking us, but did not repeat yet
6234                                     break; // (or we would have caught him before). Abort repetition-checking loop.
6235                                 // Now check for perpetual chases
6236                                 if(!ourPerpetual && !hisPerpetual) { // no perpetual check, test for chase
6237                                     hisPerpetual = PerpetualChase(k, forwardMostMove);
6238                                     ourPerpetual = PerpetualChase(k+1, forwardMostMove);
6239                                     if(ourPerpetual && !hisPerpetual) { // we are actively chasing him: forfeit
6240                                         GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
6241                                                       "Xboard adjudication: perpetual chasing", GE_XBOARD );
6242                                         return;
6243                                     }
6244                                     if(hisPerpetual && !ourPerpetual)   // he is chasing us, but did not repeat yet
6245                                         break; // Abort repetition-checking loop.
6246                                 }
6247                                 // if neither of us is checking or chasing all the time, or both are, it is draw
6248                              }
6249                              GameEnds( GameIsDrawn, "Xboard adjudication: repetition draw", GE_XBOARD );
6250                              return;
6251                         }
6252                         if( rights == 0 && count > 1 ) /* occurred 2 or more times before */
6253                              epStatus[forwardMostMove] = EP_REP_DRAW;
6254                     }
6255                 }
6256
6257                 /* Now we test for 50-move draws. Determine ply count */
6258                 count = forwardMostMove;
6259                 /* look for last irreversble move */
6260                 while( epStatus[count] <= EP_NONE && count > backwardMostMove )
6261                     count--;
6262                 /* if we hit starting position, add initial plies */
6263                 if( count == backwardMostMove )
6264                     count -= initialRulePlies;
6265                 count = forwardMostMove - count;
6266                 if( count >= 100)
6267                          epStatus[forwardMostMove] = EP_RULE_DRAW;
6268                          /* this is used to judge if draw claims are legal */
6269                 if(appData.ruleMoves > 0 && count >= 2*appData.ruleMoves) {
6270                          SendToProgram("force\n", cps->other); // suppress reply
6271                          SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6272                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6273                          GameEnds( GameIsDrawn, "Xboard adjudication: 50-move rule", GE_XBOARD );
6274                          return;
6275                 }
6276
6277                 /* if draw offer is pending, treat it as a draw claim
6278                  * when draw condition present, to allow engines a way to
6279                  * claim draws before making their move to avoid a race
6280                  * condition occurring after their move
6281                  */
6282                 if( cps->other->offeredDraw || cps->offeredDraw ) {
6283                          char *p = NULL;
6284                          if(epStatus[forwardMostMove] == EP_RULE_DRAW)
6285                              p = "Draw claim: 50-move rule";
6286                          if(epStatus[forwardMostMove] == EP_REP_DRAW)
6287                              p = "Draw claim: 3-fold repetition";
6288                          if(epStatus[forwardMostMove] == EP_INSUF_DRAW)
6289                              p = "Draw claim: insufficient mating material";
6290                          if( p != NULL ) {
6291                              SendToProgram("force\n", cps->other); // suppress reply
6292                              SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6293                              GameEnds( GameIsDrawn, p, GE_XBOARD );
6294                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6295                              return;
6296                          }
6297                 }
6298
6299
6300                 if( appData.adjudicateDrawMoves > 0 && forwardMostMove > (2*appData.adjudicateDrawMoves) ) {
6301                     SendToProgram("force\n", cps->other); // suppress reply
6302                     SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6303                     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6304
6305                     GameEnds( GameIsDrawn, "Xboard adjudication: long game", GE_XBOARD );
6306
6307                     return;
6308                 }
6309         }
6310
6311         bookHit = NULL;
6312         if (gameMode == TwoMachinesPlay) {
6313             /* [HGM] relaying draw offers moved to after reception of move */
6314             /* and interpreting offer as claim if it brings draw condition */
6315             if (cps->offeredDraw == 1 && cps->other->sendDrawOffers) {
6316                 SendToProgram("draw\n", cps->other);
6317             }
6318             if (cps->other->sendTime) {
6319                 SendTimeRemaining(cps->other,
6320                                   cps->other->twoMachinesColor[0] == 'w');
6321             }
6322             bookHit = SendMoveToBookUser(forwardMostMove-1, cps->other, FALSE);
6323             if (firstMove && !bookHit) {
6324                 firstMove = FALSE;
6325                 if (cps->other->useColors) {
6326                   SendToProgram(cps->other->twoMachinesColor, cps->other);
6327                 }
6328                 SendToProgram("go\n", cps->other);
6329             }
6330             cps->other->maybeThinking = TRUE;
6331         }
6332
6333         ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6334
6335         if (!pausing && appData.ringBellAfterMoves) {
6336             RingBell();
6337         }
6338
6339         /*
6340          * Reenable menu items that were disabled while
6341          * machine was thinking
6342          */
6343         if (gameMode != TwoMachinesPlay)
6344             SetUserThinkingEnables();
6345
6346         // [HGM] book: after book hit opponent has received move and is now in force mode
6347         // force the book reply into it, and then fake that it outputted this move by jumping
6348         // back to the beginning of HandleMachineMove, with cps toggled and message set to this move
6349         if(bookHit) {
6350                 static char bookMove[MSG_SIZ]; // a bit generous?
6351
6352                 strcpy(bookMove, "move ");
6353                 strcat(bookMove, bookHit);
6354                 message = bookMove;
6355                 cps = cps->other;
6356                 programStats.nodes = programStats.depth = programStats.time =
6357                 programStats.score = programStats.got_only_move = 0;
6358                 sprintf(programStats.movelist, "%s (xbook)", bookHit);
6359
6360                 if(cps->lastPing != cps->lastPong) {
6361                     savedMessage = message; // args for deferred call
6362                     savedState = cps;
6363                     ScheduleDelayedEvent(DeferredBookMove, 10);
6364                     return;
6365                 }
6366                 goto FakeBookMove;
6367         }
6368
6369         return;
6370     }
6371
6372     /* Set special modes for chess engines.  Later something general
6373      *  could be added here; for now there is just one kludge feature,
6374      *  needed because Crafty 15.10 and earlier don't ignore SIGINT
6375      *  when "xboard" is given as an interactive command.
6376      */
6377     if (strncmp(message, "kibitz Hello from Crafty", 24) == 0) {
6378         cps->useSigint = FALSE;
6379         cps->useSigterm = FALSE;
6380     }
6381     if (strncmp(message, "feature ", 8) == 0) { // [HGM] moved forward to pre-empt non-compliant commands
6382       ParseFeatures(message+8, cps);
6383       return; // [HGM] This return was missing, causing option features to be recognized as non-compliant commands!
6384     }
6385
6386     /* [HGM] Allow engine to set up a position. Don't ask me why one would
6387      * want this, I was asked to put it in, and obliged.
6388      */
6389     if (!strncmp(message, "setboard ", 9)) {
6390         Board initial_position; int i;
6391
6392         GameEnds(GameUnfinished, "Engine aborts game", GE_XBOARD);
6393
6394         if (!ParseFEN(initial_position, &blackPlaysFirst, message + 9)) {
6395             DisplayError(_("Bad FEN received from engine"), 0);
6396             return ;
6397         } else {
6398            Reset(FALSE, FALSE);
6399            CopyBoard(boards[0], initial_position);
6400            initialRulePlies = FENrulePlies;
6401            epStatus[0] = FENepStatus;
6402            for( i=0; i<nrCastlingRights; i++ )
6403                 castlingRights[0][i] = FENcastlingRights[i];
6404            if(blackPlaysFirst) gameMode = MachinePlaysWhite;
6405            else gameMode = MachinePlaysBlack;
6406            DrawPosition(FALSE, boards[currentMove]);
6407         }
6408         return;
6409     }
6410
6411     /*
6412      * Look for communication commands
6413      */
6414     if (!strncmp(message, "telluser ", 9)) {
6415         DisplayNote(message + 9);
6416         return;
6417     }
6418     if (!strncmp(message, "tellusererror ", 14)) {
6419         DisplayError(message + 14, 0);
6420         return;
6421     }
6422     if (!strncmp(message, "tellopponent ", 13)) {
6423       if (appData.icsActive) {
6424         if (loggedOn) {
6425           snprintf(buf1, sizeof(buf1), "%ssay %s\n", ics_prefix, message + 13);
6426           SendToICS(buf1);
6427         }
6428       } else {
6429         DisplayNote(message + 13);
6430       }
6431       return;
6432     }
6433     if (!strncmp(message, "tellothers ", 11)) {
6434       if (appData.icsActive) {
6435         if (loggedOn) {
6436           snprintf(buf1, sizeof(buf1), "%swhisper %s\n", ics_prefix, message + 11);
6437           SendToICS(buf1);
6438         }
6439       }
6440       return;
6441     }
6442     if (!strncmp(message, "tellall ", 8)) {
6443       if (appData.icsActive) {
6444         if (loggedOn) {
6445           snprintf(buf1, sizeof(buf1), "%skibitz %s\n", ics_prefix, message + 8);
6446           SendToICS(buf1);
6447         }
6448       } else {
6449         DisplayNote(message + 8);
6450       }
6451       return;
6452     }
6453     if (strncmp(message, "warning", 7) == 0) {
6454         /* Undocumented feature, use tellusererror in new code */
6455         DisplayError(message, 0);
6456         return;
6457     }
6458     if (sscanf(message, "askuser %s %[^\n]", buf1, buf2) == 2) {
6459         strcpy(realname, cps->tidy);
6460         strcat(realname, " query");
6461         AskQuestion(realname, buf2, buf1, cps->pr);
6462         return;
6463     }
6464     /* Commands from the engine directly to ICS.  We don't allow these to be
6465      *  sent until we are logged on. Crafty kibitzes have been known to
6466      *  interfere with the login process.
6467      */
6468     if (loggedOn) {
6469         if (!strncmp(message, "tellics ", 8)) {
6470             SendToICS(message + 8);
6471             SendToICS("\n");
6472             return;
6473         }
6474         if (!strncmp(message, "tellicsnoalias ", 15)) {
6475             SendToICS(ics_prefix);
6476             SendToICS(message + 15);
6477             SendToICS("\n");
6478             return;
6479         }
6480         /* The following are for backward compatibility only */
6481         if (!strncmp(message,"whisper",7) || !strncmp(message,"kibitz",6) ||
6482             !strncmp(message,"draw",4) || !strncmp(message,"tell",3)) {
6483             SendToICS(ics_prefix);
6484             SendToICS(message);
6485             SendToICS("\n");
6486             return;
6487         }
6488     }
6489     if (sscanf(message, "pong %d", &cps->lastPong) == 1) {
6490         return;
6491     }
6492     /*
6493      * If the move is illegal, cancel it and redraw the board.
6494      * Also deal with other error cases.  Matching is rather loose
6495      * here to accommodate engines written before the spec.
6496      */
6497     if (strncmp(message + 1, "llegal move", 11) == 0 ||
6498         strncmp(message, "Error", 5) == 0) {
6499         if (StrStr(message, "name") ||
6500             StrStr(message, "rating") || StrStr(message, "?") ||
6501             StrStr(message, "result") || StrStr(message, "board") ||
6502             StrStr(message, "bk") || StrStr(message, "computer") ||
6503             StrStr(message, "variant") || StrStr(message, "hint") ||
6504             StrStr(message, "random") || StrStr(message, "depth") ||
6505             StrStr(message, "accepted")) {
6506             return;
6507         }
6508         if (StrStr(message, "protover")) {
6509           /* Program is responding to input, so it's apparently done
6510              initializing, and this error message indicates it is
6511              protocol version 1.  So we don't need to wait any longer
6512              for it to initialize and send feature commands. */
6513           FeatureDone(cps, 1);
6514           cps->protocolVersion = 1;
6515           return;
6516         }
6517         cps->maybeThinking = FALSE;
6518
6519         if (StrStr(message, "draw")) {
6520             /* Program doesn't have "draw" command */
6521             cps->sendDrawOffers = 0;
6522             return;
6523         }
6524         if (cps->sendTime != 1 &&
6525             (StrStr(message, "time") || StrStr(message, "otim"))) {
6526           /* Program apparently doesn't have "time" or "otim" command */
6527           cps->sendTime = 0;
6528           return;
6529         }
6530         if (StrStr(message, "analyze")) {
6531             cps->analysisSupport = FALSE;
6532             cps->analyzing = FALSE;
6533             Reset(FALSE, TRUE);
6534             sprintf(buf2, _("%s does not support analysis"), cps->tidy);
6535             DisplayError(buf2, 0);
6536             return;
6537         }
6538         if (StrStr(message, "(no matching move)st")) {
6539           /* Special kludge for GNU Chess 4 only */
6540           cps->stKludge = TRUE;
6541           SendTimeControl(cps, movesPerSession, timeControl,
6542                           timeIncrement, appData.searchDepth,
6543                           searchTime);
6544           return;
6545         }
6546         if (StrStr(message, "(no matching move)sd")) {
6547           /* Special kludge for GNU Chess 4 only */
6548           cps->sdKludge = TRUE;
6549           SendTimeControl(cps, movesPerSession, timeControl,
6550                           timeIncrement, appData.searchDepth,
6551                           searchTime);
6552           return;
6553         }
6554         if (!StrStr(message, "llegal")) {
6555             return;
6556         }
6557         if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
6558             gameMode == IcsIdle) return;
6559         if (forwardMostMove <= backwardMostMove) return;
6560         if (pausing) PauseEvent();
6561       if(appData.forceIllegal) {
6562             // [HGM] illegal: machine refused move; force position after move into it
6563           SendToProgram("force\n", cps);
6564           if(!cps->useSetboard) { // hideous kludge on kludge, because SendBoard sucks.
6565                 // we have a real problem now, as SendBoard will use the a2a3 kludge
6566                 // when black is to move, while there might be nothing on a2 or black
6567                 // might already have the move. So send the board as if white has the move.
6568                 // But first we must change the stm of the engine, as it refused the last move
6569                 SendBoard(cps, 0); // always kludgeless, as white is to move on boards[0]
6570                 if(WhiteOnMove(forwardMostMove)) {
6571                     SendToProgram("a7a6\n", cps); // for the engine black still had the move
6572                     SendBoard(cps, forwardMostMove); // kludgeless board
6573                 } else {
6574                     SendToProgram("a2a3\n", cps); // for the engine white still had the move
6575                     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
6576                     SendBoard(cps, forwardMostMove+1); // kludgeless board
6577                 }
6578           } else SendBoard(cps, forwardMostMove); // FEN case, also sets stm properly
6579             if(gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
6580                  gameMode == TwoMachinesPlay)
6581               SendToProgram("go\n", cps);
6582             return;
6583       } else
6584         if (gameMode == PlayFromGameFile) {
6585             /* Stop reading this game file */
6586             gameMode = EditGame;
6587             ModeHighlight();
6588         }
6589         currentMove = --forwardMostMove;
6590         DisplayMove(currentMove-1); /* before DisplayMoveError */
6591         SwitchClocks();
6592         DisplayBothClocks();
6593         sprintf(buf1, _("Illegal move \"%s\" (rejected by %s chess program)"),
6594                 parseList[currentMove], cps->which);
6595         DisplayMoveError(buf1);
6596         DrawPosition(FALSE, boards[currentMove]);
6597
6598         /* [HGM] illegal-move claim should forfeit game when Xboard */
6599         /* only passes fully legal moves                            */
6600         if( appData.testLegality && gameMode == TwoMachinesPlay ) {
6601             GameEnds( cps->twoMachinesColor[0] == 'w' ? BlackWins : WhiteWins,
6602                                 "False illegal-move claim", GE_XBOARD );
6603         }
6604         return;
6605     }
6606     if (strncmp(message, "time", 4) == 0 && StrStr(message, "Illegal")) {
6607         /* Program has a broken "time" command that
6608            outputs a string not ending in newline.
6609            Don't use it. */
6610         cps->sendTime = 0;
6611     }
6612
6613     /*
6614      * If chess program startup fails, exit with an error message.
6615      * Attempts to recover here are futile.
6616      */
6617     if ((StrStr(message, "unknown host") != NULL)
6618         || (StrStr(message, "No remote directory") != NULL)
6619         || (StrStr(message, "not found") != NULL)
6620         || (StrStr(message, "No such file") != NULL)
6621         || (StrStr(message, "can't alloc") != NULL)
6622         || (StrStr(message, "Permission denied") != NULL)) {
6623
6624         cps->maybeThinking = FALSE;
6625         snprintf(buf1, sizeof(buf1), _("Failed to start %s chess program %s on %s: %s\n"),
6626                 cps->which, cps->program, cps->host, message);
6627         RemoveInputSource(cps->isr);
6628         DisplayFatalError(buf1, 0, 1);
6629         return;
6630     }
6631
6632     /*
6633      * Look for hint output
6634      */
6635     if (sscanf(message, "Hint: %s", buf1) == 1) {
6636         if (cps == &first && hintRequested) {
6637             hintRequested = FALSE;
6638             if (ParseOneMove(buf1, forwardMostMove, &moveType,
6639                                  &fromX, &fromY, &toX, &toY, &promoChar)) {
6640                 (void) CoordsToAlgebraic(boards[forwardMostMove],
6641                                     PosFlags(forwardMostMove), EP_UNKNOWN,
6642                                     fromY, fromX, toY, toX, promoChar, buf1);
6643                 snprintf(buf2, sizeof(buf2), _("Hint: %s"), buf1);
6644                 DisplayInformation(buf2);
6645             } else {
6646                 /* Hint move could not be parsed!? */
6647               snprintf(buf2, sizeof(buf2),
6648                         _("Illegal hint move \"%s\"\nfrom %s chess program"),
6649                         buf1, cps->which);
6650                 DisplayError(buf2, 0);
6651             }
6652         } else {
6653             strcpy(lastHint, buf1);
6654         }
6655         return;
6656     }
6657
6658     /*
6659      * Ignore other messages if game is not in progress
6660      */
6661     if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
6662         gameMode == IcsIdle || cps->lastPing != cps->lastPong) return;
6663
6664     /*
6665      * look for win, lose, draw, or draw offer
6666      */
6667     if (strncmp(message, "1-0", 3) == 0) {
6668         char *p, *q, *r = "";
6669         p = strchr(message, '{');
6670         if (p) {
6671             q = strchr(p, '}');
6672             if (q) {
6673                 *q = NULLCHAR;
6674                 r = p + 1;
6675             }
6676         }
6677         GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first)); /* [HGM] pass claimer indication for claim test */
6678         return;
6679     } else if (strncmp(message, "0-1", 3) == 0) {
6680         char *p, *q, *r = "";
6681         p = strchr(message, '{');
6682         if (p) {
6683             q = strchr(p, '}');
6684             if (q) {
6685                 *q = NULLCHAR;
6686                 r = p + 1;
6687             }
6688         }
6689         /* Kludge for Arasan 4.1 bug */
6690         if (strcmp(r, "Black resigns") == 0) {
6691             GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first));
6692             return;
6693         }
6694         GameEnds(BlackWins, r, GE_ENGINE1 + (cps != &first));
6695         return;
6696     } else if (strncmp(message, "1/2", 3) == 0) {
6697         char *p, *q, *r = "";
6698         p = strchr(message, '{');
6699         if (p) {
6700             q = strchr(p, '}');
6701             if (q) {
6702                 *q = NULLCHAR;
6703                 r = p + 1;
6704             }
6705         }
6706
6707         GameEnds(GameIsDrawn, r, GE_ENGINE1 + (cps != &first));
6708         return;
6709
6710     } else if (strncmp(message, "White resign", 12) == 0) {
6711         GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
6712         return;
6713     } else if (strncmp(message, "Black resign", 12) == 0) {
6714         GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
6715         return;
6716     } else if (strncmp(message, "White matches", 13) == 0 ||
6717                strncmp(message, "Black matches", 13) == 0   ) {
6718         /* [HGM] ignore GNUShogi noises */
6719         return;
6720     } else if (strncmp(message, "White", 5) == 0 &&
6721                message[5] != '(' &&
6722                StrStr(message, "Black") == NULL) {
6723         GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
6724         return;
6725     } else if (strncmp(message, "Black", 5) == 0 &&
6726                message[5] != '(') {
6727         GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
6728         return;
6729     } else if (strcmp(message, "resign") == 0 ||
6730                strcmp(message, "computer resigns") == 0) {
6731         switch (gameMode) {
6732           case MachinePlaysBlack:
6733           case IcsPlayingBlack:
6734             GameEnds(WhiteWins, "Black resigns", GE_ENGINE);
6735             break;
6736           case MachinePlaysWhite:
6737           case IcsPlayingWhite:
6738             GameEnds(BlackWins, "White resigns", GE_ENGINE);
6739             break;
6740           case TwoMachinesPlay:
6741             if (cps->twoMachinesColor[0] == 'w')
6742               GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
6743             else
6744               GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
6745             break;
6746           default:
6747             /* can't happen */
6748             break;
6749         }
6750         return;
6751     } else if (strncmp(message, "opponent mates", 14) == 0) {
6752         switch (gameMode) {
6753           case MachinePlaysBlack:
6754           case IcsPlayingBlack:
6755             GameEnds(WhiteWins, "White mates", GE_ENGINE);
6756             break;
6757           case MachinePlaysWhite:
6758           case IcsPlayingWhite:
6759             GameEnds(BlackWins, "Black mates", GE_ENGINE);
6760             break;
6761           case TwoMachinesPlay:
6762             if (cps->twoMachinesColor[0] == 'w')
6763               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
6764             else
6765               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
6766             break;
6767           default:
6768             /* can't happen */
6769             break;
6770         }
6771         return;
6772     } else if (strncmp(message, "computer mates", 14) == 0) {
6773         switch (gameMode) {
6774           case MachinePlaysBlack:
6775           case IcsPlayingBlack:
6776             GameEnds(BlackWins, "Black mates", GE_ENGINE1);
6777             break;
6778           case MachinePlaysWhite:
6779           case IcsPlayingWhite:
6780             GameEnds(WhiteWins, "White mates", GE_ENGINE);
6781             break;
6782           case TwoMachinesPlay:
6783             if (cps->twoMachinesColor[0] == 'w')
6784               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
6785             else
6786               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
6787             break;
6788           default:
6789             /* can't happen */
6790             break;
6791         }
6792         return;
6793     } else if (strncmp(message, "checkmate", 9) == 0) {
6794         if (WhiteOnMove(forwardMostMove)) {
6795             GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
6796         } else {
6797             GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
6798         }
6799         return;
6800     } else if (strstr(message, "Draw") != NULL ||
6801                strstr(message, "game is a draw") != NULL) {
6802         GameEnds(GameIsDrawn, "Draw", GE_ENGINE1 + (cps != &first));
6803         return;
6804     } else if (strstr(message, "offer") != NULL &&
6805                strstr(message, "draw") != NULL) {
6806 #if ZIPPY
6807         if (appData.zippyPlay && first.initDone) {
6808             /* Relay offer to ICS */
6809             SendToICS(ics_prefix);
6810             SendToICS("draw\n");
6811         }
6812 #endif
6813         cps->offeredDraw = 2; /* valid until this engine moves twice */
6814         if (gameMode == TwoMachinesPlay) {
6815             if (cps->other->offeredDraw) {
6816                 GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
6817             /* [HGM] in two-machine mode we delay relaying draw offer      */
6818             /* until after we also have move, to see if it is really claim */
6819             }
6820         } else if (gameMode == MachinePlaysWhite ||
6821                    gameMode == MachinePlaysBlack) {
6822           if (userOfferedDraw) {
6823             DisplayInformation(_("Machine accepts your draw offer"));
6824             GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
6825           } else {
6826             DisplayInformation(_("Machine offers a draw\nSelect Action / Draw to agree"));
6827           }
6828         }
6829     }
6830
6831
6832     /*
6833      * Look for thinking output
6834      */
6835     if ( appData.showThinking // [HGM] thinking: test all options that cause this output
6836           || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
6837                                 ) {
6838         int plylev, mvleft, mvtot, curscore, time;
6839         char mvname[MOVE_LEN];
6840         u64 nodes; // [DM]
6841         char plyext;
6842         int ignore = FALSE;
6843         int prefixHint = FALSE;
6844         mvname[0] = NULLCHAR;
6845
6846         switch (gameMode) {
6847           case MachinePlaysBlack:
6848           case IcsPlayingBlack:
6849             if (WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
6850             break;
6851           case MachinePlaysWhite:
6852           case IcsPlayingWhite:
6853             if (!WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
6854             break;
6855           case AnalyzeMode:
6856           case AnalyzeFile:
6857             break;
6858           case IcsObserving: /* [DM] icsEngineAnalyze */
6859             if (!appData.icsEngineAnalyze) ignore = TRUE;
6860             break;
6861           case TwoMachinesPlay:
6862             if ((cps->twoMachinesColor[0] == 'w') != WhiteOnMove(forwardMostMove)) {
6863                 ignore = TRUE;
6864             }
6865             break;
6866           default:
6867             ignore = TRUE;
6868             break;
6869         }
6870
6871         if (!ignore) {
6872             buf1[0] = NULLCHAR;
6873             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
6874                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5) {
6875
6876                 if (plyext != ' ' && plyext != '\t') {
6877                     time *= 100;
6878                 }
6879
6880                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
6881                 if( cps->scoreIsAbsolute &&
6882                     ((gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b')) )
6883                 {
6884                     curscore = -curscore;
6885                 }
6886
6887
6888                 programStats.depth = plylev;
6889                 programStats.nodes = nodes;
6890                 programStats.time = time;
6891                 programStats.score = curscore;
6892                 programStats.got_only_move = 0;
6893
6894                 if(cps->nps >= 0) { /* [HGM] nps: use engine nodes or time to decrement clock */
6895                         int ticklen;
6896
6897                         if(cps->nps == 0) ticklen = 10*time;                    // use engine reported time
6898                         else ticklen = (1000. * u64ToDouble(nodes)) / cps->nps; // convert node count to time
6899                         if(WhiteOnMove(forwardMostMove))
6900                              whiteTimeRemaining = timeRemaining[0][forwardMostMove] - ticklen;
6901                         else blackTimeRemaining = timeRemaining[1][forwardMostMove] - ticklen;
6902                 }
6903
6904                 /* Buffer overflow protection */
6905                 if (buf1[0] != NULLCHAR) {
6906                     if (strlen(buf1) >= sizeof(programStats.movelist)
6907                         && appData.debugMode) {
6908                         fprintf(debugFP,
6909                                 "PV is too long; using the first %d bytes.\n",
6910                                 sizeof(programStats.movelist) - 1);
6911                     }
6912
6913                     safeStrCpy( programStats.movelist, buf1, sizeof(programStats.movelist) );
6914                 } else {
6915                     sprintf(programStats.movelist, " no PV\n");
6916                 }
6917
6918                 if (programStats.seen_stat) {
6919                     programStats.ok_to_send = 1;
6920                 }
6921
6922                 if (strchr(programStats.movelist, '(') != NULL) {
6923                     programStats.line_is_book = 1;
6924                     programStats.nr_moves = 0;
6925                     programStats.moves_left = 0;
6926                 } else {
6927                     programStats.line_is_book = 0;
6928                 }
6929
6930                 SendProgramStatsToFrontend( cps, &programStats );
6931
6932                 /*
6933                     [AS] Protect the thinkOutput buffer from overflow... this
6934                     is only useful if buf1 hasn't overflowed first!
6935                 */
6936                 sprintf(thinkOutput, "[%d]%c%+.2f %s%s",
6937                         plylev,
6938                         (gameMode == TwoMachinesPlay ?
6939                          ToUpper(cps->twoMachinesColor[0]) : ' '),
6940                         ((double) curscore) / 100.0,
6941                         prefixHint ? lastHint : "",
6942                         prefixHint ? " " : "" );
6943
6944                 if( buf1[0] != NULLCHAR ) {
6945                     unsigned max_len = sizeof(thinkOutput) - strlen(thinkOutput) - 1;
6946
6947                     if( strlen(buf1) > max_len ) {
6948                         if( appData.debugMode) {
6949                             fprintf(debugFP,"PV is too long for thinkOutput, truncating.\n");
6950                         }
6951                         buf1[max_len+1] = '\0';
6952                     }
6953
6954                     strcat( thinkOutput, buf1 );
6955                 }
6956
6957                 if (currentMove == forwardMostMove || gameMode == AnalyzeMode
6958                         || gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
6959                     DisplayMove(currentMove - 1);
6960                 }
6961                 return;
6962
6963             } else if ((p=StrStr(message, "(only move)")) != NULL) {
6964                 /* crafty (9.25+) says "(only move) <move>"
6965                  * if there is only 1 legal move
6966                  */
6967                 sscanf(p, "(only move) %s", buf1);
6968                 sprintf(thinkOutput, "%s (only move)", buf1);
6969                 sprintf(programStats.movelist, "%s (only move)", buf1);
6970                 programStats.depth = 1;
6971                 programStats.nr_moves = 1;
6972                 programStats.moves_left = 1;
6973                 programStats.nodes = 1;
6974                 programStats.time = 1;
6975                 programStats.got_only_move = 1;
6976
6977                 /* Not really, but we also use this member to
6978                    mean "line isn't going to change" (Crafty
6979                    isn't searching, so stats won't change) */
6980                 programStats.line_is_book = 1;
6981
6982                 SendProgramStatsToFrontend( cps, &programStats );
6983
6984                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
6985                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
6986                     DisplayMove(currentMove - 1);
6987                 }
6988                 return;
6989             } else if (sscanf(message,"stat01: %d " u64Display " %d %d %d %s",
6990                               &time, &nodes, &plylev, &mvleft,
6991                               &mvtot, mvname) >= 5) {
6992                 /* The stat01: line is from Crafty (9.29+) in response
6993                    to the "." command */
6994                 programStats.seen_stat = 1;
6995                 cps->maybeThinking = TRUE;
6996
6997                 if (programStats.got_only_move || !appData.periodicUpdates)
6998                   return;
6999
7000                 programStats.depth = plylev;
7001                 programStats.time = time;
7002                 programStats.nodes = nodes;
7003                 programStats.moves_left = mvleft;
7004                 programStats.nr_moves = mvtot;
7005                 strcpy(programStats.move_name, mvname);
7006                 programStats.ok_to_send = 1;
7007                 programStats.movelist[0] = '\0';
7008
7009                 SendProgramStatsToFrontend( cps, &programStats );
7010
7011                 return;
7012
7013             } else if (strncmp(message,"++",2) == 0) {
7014                 /* Crafty 9.29+ outputs this */
7015                 programStats.got_fail = 2;
7016                 return;
7017
7018             } else if (strncmp(message,"--",2) == 0) {
7019                 /* Crafty 9.29+ outputs this */
7020                 programStats.got_fail = 1;
7021                 return;
7022
7023             } else if (thinkOutput[0] != NULLCHAR &&
7024                        strncmp(message, "    ", 4) == 0) {
7025                 unsigned message_len;
7026
7027                 p = message;
7028                 while (*p && *p == ' ') p++;
7029
7030                 message_len = strlen( p );
7031
7032                 /* [AS] Avoid buffer overflow */
7033                 if( sizeof(thinkOutput) - strlen(thinkOutput) - 1 > message_len ) {
7034                     strcat(thinkOutput, " ");
7035                     strcat(thinkOutput, p);
7036                 }
7037
7038                 if( sizeof(programStats.movelist) - strlen(programStats.movelist) - 1 > message_len ) {
7039                     strcat(programStats.movelist, " ");
7040                     strcat(programStats.movelist, p);
7041                 }
7042
7043                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
7044                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
7045                     DisplayMove(currentMove - 1);
7046                 }
7047                 return;
7048             }
7049         }
7050         else {
7051             buf1[0] = NULLCHAR;
7052
7053             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
7054                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5)
7055             {
7056                 ChessProgramStats cpstats;
7057
7058                 if (plyext != ' ' && plyext != '\t') {
7059                     time *= 100;
7060                 }
7061
7062                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
7063                 if( cps->scoreIsAbsolute && ((gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b')) ) {
7064                     curscore = -curscore;
7065                 }
7066
7067                 cpstats.depth = plylev;
7068                 cpstats.nodes = nodes;
7069                 cpstats.time = time;
7070                 cpstats.score = curscore;
7071                 cpstats.got_only_move = 0;
7072                 cpstats.movelist[0] = '\0';
7073
7074                 if (buf1[0] != NULLCHAR) {
7075                     safeStrCpy( cpstats.movelist, buf1, sizeof(cpstats.movelist) );
7076                 }
7077
7078                 cpstats.ok_to_send = 0;
7079                 cpstats.line_is_book = 0;
7080                 cpstats.nr_moves = 0;
7081                 cpstats.moves_left = 0;
7082
7083                 SendProgramStatsToFrontend( cps, &cpstats );
7084             }
7085         }
7086     }
7087 }
7088
7089
7090 /* Parse a game score from the character string "game", and
7091    record it as the history of the current game.  The game
7092    score is NOT assumed to start from the standard position.
7093    The display is not updated in any way.
7094    */
7095 void
7096 ParseGameHistory(game)
7097      char *game;
7098 {
7099     ChessMove moveType;
7100     int fromX, fromY, toX, toY, boardIndex;
7101     char promoChar;
7102     char *p, *q;
7103     char buf[MSG_SIZ];
7104
7105     if (appData.debugMode)
7106       fprintf(debugFP, "Parsing game history: %s\n", game);
7107
7108     if (gameInfo.event == NULL) gameInfo.event = StrSave("ICS game");
7109     gameInfo.site = StrSave(appData.icsHost);
7110     gameInfo.date = PGNDate();
7111     gameInfo.round = StrSave("-");
7112
7113     /* Parse out names of players */
7114     while (*game == ' ') game++;
7115     p = buf;
7116     while (*game != ' ') *p++ = *game++;
7117     *p = NULLCHAR;
7118     gameInfo.white = StrSave(buf);
7119     while (*game == ' ') game++;
7120     p = buf;
7121     while (*game != ' ' && *game != '\n') *p++ = *game++;
7122     *p = NULLCHAR;
7123     gameInfo.black = StrSave(buf);
7124
7125     /* Parse moves */
7126     boardIndex = blackPlaysFirst ? 1 : 0;
7127     yynewstr(game);
7128     for (;;) {
7129         yyboardindex = boardIndex;
7130         moveType = (ChessMove) yylex();
7131         switch (moveType) {
7132           case IllegalMove:             /* maybe suicide chess, etc. */
7133   if (appData.debugMode) {
7134     fprintf(debugFP, "Illegal move from ICS: '%s'\n", yy_text);
7135     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
7136     setbuf(debugFP, NULL);
7137   }
7138           case WhitePromotionChancellor:
7139           case BlackPromotionChancellor:
7140           case WhitePromotionArchbishop:
7141           case BlackPromotionArchbishop:
7142           case WhitePromotionQueen:
7143           case BlackPromotionQueen:
7144           case WhitePromotionRook:
7145           case BlackPromotionRook:
7146           case WhitePromotionBishop:
7147           case BlackPromotionBishop:
7148           case WhitePromotionKnight:
7149           case BlackPromotionKnight:
7150           case WhitePromotionKing:
7151           case BlackPromotionKing:
7152           case NormalMove:
7153           case WhiteCapturesEnPassant:
7154           case BlackCapturesEnPassant:
7155           case WhiteKingSideCastle:
7156           case WhiteQueenSideCastle:
7157           case BlackKingSideCastle:
7158           case BlackQueenSideCastle:
7159           case WhiteKingSideCastleWild:
7160           case WhiteQueenSideCastleWild:
7161           case BlackKingSideCastleWild:
7162           case BlackQueenSideCastleWild:
7163           /* PUSH Fabien */
7164           case WhiteHSideCastleFR:
7165           case WhiteASideCastleFR:
7166           case BlackHSideCastleFR:
7167           case BlackASideCastleFR:
7168           /* POP Fabien */
7169             fromX = currentMoveString[0] - AAA;
7170             fromY = currentMoveString[1] - ONE;
7171             toX = currentMoveString[2] - AAA;
7172             toY = currentMoveString[3] - ONE;
7173             promoChar = currentMoveString[4];
7174             break;
7175           case WhiteDrop:
7176           case BlackDrop:
7177             fromX = moveType == WhiteDrop ?
7178               (int) CharToPiece(ToUpper(currentMoveString[0])) :
7179             (int) CharToPiece(ToLower(currentMoveString[0]));
7180             fromY = DROP_RANK;
7181             toX = currentMoveString[2] - AAA;
7182             toY = currentMoveString[3] - ONE;
7183             promoChar = NULLCHAR;
7184             break;
7185           case AmbiguousMove:
7186             /* bug? */
7187             sprintf(buf, _("Ambiguous move in ICS output: \"%s\""), yy_text);
7188   if (appData.debugMode) {
7189     fprintf(debugFP, "Ambiguous move from ICS: '%s'\n", yy_text);
7190     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
7191     setbuf(debugFP, NULL);
7192   }
7193             DisplayError(buf, 0);
7194             return;
7195           case ImpossibleMove:
7196             /* bug? */
7197             sprintf(buf, _("Illegal move in ICS output: \"%s\""), yy_text);
7198   if (appData.debugMode) {
7199     fprintf(debugFP, "Impossible move from ICS: '%s'\n", yy_text);
7200     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
7201     setbuf(debugFP, NULL);
7202   }
7203             DisplayError(buf, 0);
7204             return;
7205           case (ChessMove) 0:   /* end of file */
7206             if (boardIndex < backwardMostMove) {
7207                 /* Oops, gap.  How did that happen? */
7208                 DisplayError(_("Gap in move list"), 0);
7209                 return;
7210             }
7211             backwardMostMove =  blackPlaysFirst ? 1 : 0;
7212             if (boardIndex > forwardMostMove) {
7213                 forwardMostMove = boardIndex;
7214             }
7215             return;
7216           case ElapsedTime:
7217             if (boardIndex > (blackPlaysFirst ? 1 : 0)) {
7218                 strcat(parseList[boardIndex-1], " ");
7219                 strcat(parseList[boardIndex-1], yy_text);
7220             }
7221             continue;
7222           case Comment:
7223           case PGNTag:
7224           case NAG:
7225           default:
7226             /* ignore */
7227             continue;
7228           case WhiteWins:
7229           case BlackWins:
7230           case GameIsDrawn:
7231           case GameUnfinished:
7232             if (gameMode == IcsExamining) {
7233                 if (boardIndex < backwardMostMove) {
7234                     /* Oops, gap.  How did that happen? */
7235                     return;
7236                 }
7237                 backwardMostMove = blackPlaysFirst ? 1 : 0;
7238                 return;
7239             }
7240             gameInfo.result = moveType;
7241             p = strchr(yy_text, '{');
7242             if (p == NULL) p = strchr(yy_text, '(');
7243             if (p == NULL) {
7244                 p = yy_text;
7245                 if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
7246             } else {
7247                 q = strchr(p, *p == '{' ? '}' : ')');
7248                 if (q != NULL) *q = NULLCHAR;
7249                 p++;
7250             }
7251             gameInfo.resultDetails = StrSave(p);
7252             continue;
7253         }
7254         if (boardIndex >= forwardMostMove &&
7255             !(gameMode == IcsObserving && ics_gamenum == -1)) {
7256             backwardMostMove = blackPlaysFirst ? 1 : 0;
7257             return;
7258         }
7259         (void) CoordsToAlgebraic(boards[boardIndex], PosFlags(boardIndex),
7260                                  EP_UNKNOWN, fromY, fromX, toY, toX, promoChar,
7261                                  parseList[boardIndex]);
7262         CopyBoard(boards[boardIndex + 1], boards[boardIndex]);
7263         {int i; for(i=0; i<BOARD_SIZE; i++) castlingRights[boardIndex+1][i] = castlingRights[boardIndex][i];}
7264         /* currentMoveString is set as a side-effect of yylex */
7265         strcpy(moveList[boardIndex], currentMoveString);
7266         strcat(moveList[boardIndex], "\n");
7267         boardIndex++;
7268         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[boardIndex],
7269                                         castlingRights[boardIndex], &epStatus[boardIndex]);
7270         switch (MateTest(boards[boardIndex], PosFlags(boardIndex),
7271                                  EP_UNKNOWN, castlingRights[boardIndex]) ) {
7272           case MT_NONE:
7273           case MT_STALEMATE:
7274           default:
7275             break;
7276           case MT_CHECK:
7277             if(gameInfo.variant != VariantShogi)
7278                 strcat(parseList[boardIndex - 1], "+");
7279             break;
7280           case MT_CHECKMATE:
7281           case MT_STAINMATE:
7282             strcat(parseList[boardIndex - 1], "#");
7283             break;
7284         }
7285     }
7286 }
7287
7288
7289 /* Apply a move to the given board  */
7290 void
7291 ApplyMove(fromX, fromY, toX, toY, promoChar, board, castling, ep)
7292      int fromX, fromY, toX, toY;
7293      int promoChar;
7294      Board board;
7295      char *castling;
7296      char *ep;
7297 {
7298   ChessSquare captured = board[toY][toX], piece, king; int p, oldEP = EP_NONE, berolina = 0;
7299
7300     /* [HGM] compute & store e.p. status and castling rights for new position */
7301     /* we can always do that 'in place', now pointers to these rights are passed to ApplyMove */
7302     { int i;
7303
7304       if(gameInfo.variant == VariantBerolina) berolina = EP_BEROLIN_A;
7305       oldEP = *ep;
7306       *ep = EP_NONE;
7307
7308       if( board[toY][toX] != EmptySquare )
7309            *ep = EP_CAPTURE;
7310
7311       if( board[fromY][fromX] == WhitePawn ) {
7312            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
7313                *ep = EP_PAWN_MOVE;
7314            if( toY-fromY==2) {
7315                if(toX>BOARD_LEFT   && board[toY][toX-1] == BlackPawn &&
7316                         gameInfo.variant != VariantBerolina || toX < fromX)
7317                       *ep = toX | berolina;
7318                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == BlackPawn &&
7319                         gameInfo.variant != VariantBerolina || toX > fromX)
7320                       *ep = toX;
7321            }
7322       } else
7323       if( board[fromY][fromX] == BlackPawn ) {
7324            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
7325                *ep = EP_PAWN_MOVE;
7326            if( toY-fromY== -2) {
7327                if(toX>BOARD_LEFT   && board[toY][toX-1] == WhitePawn &&
7328                         gameInfo.variant != VariantBerolina || toX < fromX)
7329                       *ep = toX | berolina;
7330                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == WhitePawn &&
7331                         gameInfo.variant != VariantBerolina || toX > fromX)
7332                       *ep = toX;
7333            }
7334        }
7335
7336        for(i=0; i<nrCastlingRights; i++) {
7337            if(castling[i] == fromX && castlingRank[i] == fromY ||
7338               castling[i] == toX   && castlingRank[i] == toY
7339              ) castling[i] = -1; // revoke for moved or captured piece
7340        }
7341
7342     }
7343
7344   /* [HGM] In Shatranj and Courier all promotions are to Ferz */
7345   if((gameInfo.variant==VariantShatranj || gameInfo.variant==VariantCourier)
7346        && promoChar != 0) promoChar = PieceToChar(WhiteFerz);
7347
7348   if (fromX == toX && fromY == toY) return;
7349
7350   if (fromY == DROP_RANK) {
7351         /* must be first */
7352         piece = board[toY][toX] = (ChessSquare) fromX;
7353   } else {
7354      piece = board[fromY][fromX]; /* [HGM] remember, for Shogi promotion */
7355      king = piece < (int) BlackPawn ? WhiteKing : BlackKing; /* [HGM] Knightmate simplify testing for castling */
7356      if(gameInfo.variant == VariantKnightmate)
7357          king += (int) WhiteUnicorn - (int) WhiteKing;
7358
7359     /* Code added by Tord: */
7360     /* FRC castling assumed when king captures friendly rook. */
7361     if (board[fromY][fromX] == WhiteKing &&
7362              board[toY][toX] == WhiteRook) {
7363       board[fromY][fromX] = EmptySquare;
7364       board[toY][toX] = EmptySquare;
7365       if(toX > fromX) {
7366         board[0][BOARD_RGHT-2] = WhiteKing; board[0][BOARD_RGHT-3] = WhiteRook;
7367       } else {
7368         board[0][BOARD_LEFT+2] = WhiteKing; board[0][BOARD_LEFT+3] = WhiteRook;
7369       }
7370     } else if (board[fromY][fromX] == BlackKing &&
7371                board[toY][toX] == BlackRook) {
7372       board[fromY][fromX] = EmptySquare;
7373       board[toY][toX] = EmptySquare;
7374       if(toX > fromX) {
7375         board[BOARD_HEIGHT-1][BOARD_RGHT-2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_RGHT-3] = BlackRook;
7376       } else {
7377         board[BOARD_HEIGHT-1][BOARD_LEFT+2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_LEFT+3] = BlackRook;
7378       }
7379     /* End of code added by Tord */
7380
7381     } else if (board[fromY][fromX] == king
7382         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
7383         && toY == fromY && toX > fromX+1) {
7384         board[fromY][fromX] = EmptySquare;
7385         board[toY][toX] = king;
7386         board[toY][toX-1] = board[fromY][BOARD_RGHT-1];
7387         board[fromY][BOARD_RGHT-1] = EmptySquare;
7388     } else if (board[fromY][fromX] == king
7389         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
7390                && toY == fromY && toX < fromX-1) {
7391         board[fromY][fromX] = EmptySquare;
7392         board[toY][toX] = king;
7393         board[toY][toX+1] = board[fromY][BOARD_LEFT];
7394         board[fromY][BOARD_LEFT] = EmptySquare;
7395     } else if (board[fromY][fromX] == WhitePawn
7396                && toY == BOARD_HEIGHT-1
7397                && gameInfo.variant != VariantXiangqi
7398                ) {
7399         /* white pawn promotion */
7400         board[toY][toX] = CharToPiece(ToUpper(promoChar));
7401         if (board[toY][toX] == EmptySquare) {
7402             board[toY][toX] = WhiteQueen;
7403         }
7404         if(gameInfo.variant==VariantBughouse ||
7405            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
7406             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
7407         board[fromY][fromX] = EmptySquare;
7408     } else if ((fromY == BOARD_HEIGHT-4)
7409                && (toX != fromX)
7410                && gameInfo.variant != VariantXiangqi
7411                && gameInfo.variant != VariantBerolina
7412                && (board[fromY][fromX] == WhitePawn)
7413                && (board[toY][toX] == EmptySquare)) {
7414         board[fromY][fromX] = EmptySquare;
7415         board[toY][toX] = WhitePawn;
7416         captured = board[toY - 1][toX];
7417         board[toY - 1][toX] = EmptySquare;
7418     } else if ((fromY == BOARD_HEIGHT-4)
7419                && (toX == fromX)
7420                && gameInfo.variant == VariantBerolina
7421                && (board[fromY][fromX] == WhitePawn)
7422                && (board[toY][toX] == EmptySquare)) {
7423         board[fromY][fromX] = EmptySquare;
7424         board[toY][toX] = WhitePawn;
7425         if(oldEP & EP_BEROLIN_A) {
7426                 captured = board[fromY][fromX-1];
7427                 board[fromY][fromX-1] = EmptySquare;
7428         }else{  captured = board[fromY][fromX+1];
7429                 board[fromY][fromX+1] = EmptySquare;
7430         }
7431     } else if (board[fromY][fromX] == king
7432         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
7433                && toY == fromY && toX > fromX+1) {
7434         board[fromY][fromX] = EmptySquare;
7435         board[toY][toX] = king;
7436         board[toY][toX-1] = board[fromY][BOARD_RGHT-1];
7437         board[fromY][BOARD_RGHT-1] = EmptySquare;
7438     } else if (board[fromY][fromX] == king
7439         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
7440                && toY == fromY && toX < fromX-1) {
7441         board[fromY][fromX] = EmptySquare;
7442         board[toY][toX] = king;
7443         board[toY][toX+1] = board[fromY][BOARD_LEFT];
7444         board[fromY][BOARD_LEFT] = EmptySquare;
7445     } else if (fromY == 7 && fromX == 3
7446                && board[fromY][fromX] == BlackKing
7447                && toY == 7 && toX == 5) {
7448         board[fromY][fromX] = EmptySquare;
7449         board[toY][toX] = BlackKing;
7450         board[fromY][7] = EmptySquare;
7451         board[toY][4] = BlackRook;
7452     } else if (fromY == 7 && fromX == 3
7453                && board[fromY][fromX] == BlackKing
7454                && toY == 7 && toX == 1) {
7455         board[fromY][fromX] = EmptySquare;
7456         board[toY][toX] = BlackKing;
7457         board[fromY][0] = EmptySquare;
7458         board[toY][2] = BlackRook;
7459     } else if (board[fromY][fromX] == BlackPawn
7460                && toY == 0
7461                && gameInfo.variant != VariantXiangqi
7462                ) {
7463         /* black pawn promotion */
7464         board[0][toX] = CharToPiece(ToLower(promoChar));
7465         if (board[0][toX] == EmptySquare) {
7466             board[0][toX] = BlackQueen;
7467         }
7468         if(gameInfo.variant==VariantBughouse ||
7469            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
7470             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
7471         board[fromY][fromX] = EmptySquare;
7472     } else if ((fromY == 3)
7473                && (toX != fromX)
7474                && gameInfo.variant != VariantXiangqi
7475                && gameInfo.variant != VariantBerolina
7476                && (board[fromY][fromX] == BlackPawn)
7477                && (board[toY][toX] == EmptySquare)) {
7478         board[fromY][fromX] = EmptySquare;
7479         board[toY][toX] = BlackPawn;
7480         captured = board[toY + 1][toX];
7481         board[toY + 1][toX] = EmptySquare;
7482     } else if ((fromY == 3)
7483                && (toX == fromX)
7484                && gameInfo.variant == VariantBerolina
7485                && (board[fromY][fromX] == BlackPawn)
7486                && (board[toY][toX] == EmptySquare)) {
7487         board[fromY][fromX] = EmptySquare;
7488         board[toY][toX] = BlackPawn;
7489         if(oldEP & EP_BEROLIN_A) {
7490                 captured = board[fromY][fromX-1];
7491                 board[fromY][fromX-1] = EmptySquare;
7492         }else{  captured = board[fromY][fromX+1];
7493                 board[fromY][fromX+1] = EmptySquare;
7494         }
7495     } else {
7496         board[toY][toX] = board[fromY][fromX];
7497         board[fromY][fromX] = EmptySquare;
7498     }
7499
7500     /* [HGM] now we promote for Shogi, if needed */
7501     if(gameInfo.variant == VariantShogi && promoChar == 'q')
7502         board[toY][toX] = (ChessSquare) (PROMOTED piece);
7503   }
7504
7505     if (gameInfo.holdingsWidth != 0) {
7506
7507       /* !!A lot more code needs to be written to support holdings  */
7508       /* [HGM] OK, so I have written it. Holdings are stored in the */
7509       /* penultimate board files, so they are automaticlly stored   */
7510       /* in the game history.                                       */
7511       if (fromY == DROP_RANK) {
7512         /* Delete from holdings, by decreasing count */
7513         /* and erasing image if necessary            */
7514         p = (int) fromX;
7515         if(p < (int) BlackPawn) { /* white drop */
7516              p -= (int)WhitePawn;
7517              if(p >= gameInfo.holdingsSize) p = 0;
7518              if(--board[p][BOARD_WIDTH-2] == 0)
7519                   board[p][BOARD_WIDTH-1] = EmptySquare;
7520         } else {                  /* black drop */
7521              p -= (int)BlackPawn;
7522              if(p >= gameInfo.holdingsSize) p = 0;
7523              if(--board[BOARD_HEIGHT-1-p][1] == 0)
7524                   board[BOARD_HEIGHT-1-p][0] = EmptySquare;
7525         }
7526       }
7527       if (captured != EmptySquare && gameInfo.holdingsSize > 0
7528           && gameInfo.variant != VariantBughouse        ) {
7529         /* [HGM] holdings: Add to holdings, if holdings exist */
7530         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
7531                 // [HGM] superchess: suppress flipping color of captured pieces by reverse pre-flip
7532                 captured = (int) captured >= (int) BlackPawn ? BLACK_TO_WHITE captured : WHITE_TO_BLACK captured;
7533         }
7534         p = (int) captured;
7535         if (p >= (int) BlackPawn) {
7536           p -= (int)BlackPawn;
7537           if(gameInfo.variant == VariantShogi && DEMOTED p >= 0) {
7538                   /* in Shogi restore piece to its original  first */
7539                   captured = (ChessSquare) (DEMOTED captured);
7540                   p = DEMOTED p;
7541           }
7542           p = PieceToNumber((ChessSquare)p);
7543           if(p >= gameInfo.holdingsSize) { p = 0; captured = BlackPawn; }
7544           board[p][BOARD_WIDTH-2]++;
7545           board[p][BOARD_WIDTH-1] = BLACK_TO_WHITE captured;
7546         } else {
7547           p -= (int)WhitePawn;
7548           if(gameInfo.variant == VariantShogi && DEMOTED p >= 0) {
7549                   captured = (ChessSquare) (DEMOTED captured);
7550                   p = DEMOTED p;
7551           }
7552           p = PieceToNumber((ChessSquare)p);
7553           if(p >= gameInfo.holdingsSize) { p = 0; captured = WhitePawn; }
7554           board[BOARD_HEIGHT-1-p][1]++;
7555           board[BOARD_HEIGHT-1-p][0] = WHITE_TO_BLACK captured;
7556         }
7557       }
7558
7559     } else if (gameInfo.variant == VariantAtomic) {
7560       if (captured != EmptySquare) {
7561         int y, x;
7562         for (y = toY-1; y <= toY+1; y++) {
7563           for (x = toX-1; x <= toX+1; x++) {
7564             if (y >= 0 && y < BOARD_HEIGHT && x >= BOARD_LEFT && x < BOARD_RGHT &&
7565                 board[y][x] != WhitePawn && board[y][x] != BlackPawn) {
7566               board[y][x] = EmptySquare;
7567             }
7568           }
7569         }
7570         board[toY][toX] = EmptySquare;
7571       }
7572     }
7573     if(gameInfo.variant == VariantShogi && promoChar != NULLCHAR && promoChar != '=') {
7574         /* [HGM] Shogi promotions */
7575         board[toY][toX] = (ChessSquare) (PROMOTED piece);
7576     }
7577
7578     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
7579                 && promoChar != NULLCHAR && gameInfo.holdingsSize) {
7580         // [HGM] superchess: take promotion piece out of holdings
7581         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
7582         if((int)piece < (int)BlackPawn) { // determine stm from piece color
7583             if(!--board[k][BOARD_WIDTH-2])
7584                 board[k][BOARD_WIDTH-1] = EmptySquare;
7585         } else {
7586             if(!--board[BOARD_HEIGHT-1-k][1])
7587                 board[BOARD_HEIGHT-1-k][0] = EmptySquare;
7588         }
7589     }
7590
7591 }
7592
7593 /* Updates forwardMostMove */
7594 void
7595 MakeMove(fromX, fromY, toX, toY, promoChar)
7596      int fromX, fromY, toX, toY;
7597      int promoChar;
7598 {
7599 //    forwardMostMove++; // [HGM] bare: moved downstream
7600
7601     if(serverMoves != NULL) { /* [HGM] write moves on file for broadcasting (should be separate routine, really) */
7602         int timeLeft; static int lastLoadFlag=0; int king, piece;
7603         piece = boards[forwardMostMove][fromY][fromX];
7604         king = piece < (int) BlackPawn ? WhiteKing : BlackKing;
7605         if(gameInfo.variant == VariantKnightmate)
7606             king += (int) WhiteUnicorn - (int) WhiteKing;
7607         if(forwardMostMove == 0) {
7608             if(blackPlaysFirst)
7609                 fprintf(serverMoves, "%s;", second.tidy);
7610             fprintf(serverMoves, "%s;", first.tidy);
7611             if(!blackPlaysFirst)
7612                 fprintf(serverMoves, "%s;", second.tidy);
7613         } else fprintf(serverMoves, loadFlag|lastLoadFlag ? ":" : ";");
7614         lastLoadFlag = loadFlag;
7615         // print base move
7616         fprintf(serverMoves, "%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+toY);
7617         // print castling suffix
7618         if( toY == fromY && piece == king ) {
7619             if(toX-fromX > 1)
7620                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_RGHT-1, ONE+fromY, AAA+toX-1,ONE+toY);
7621             if(fromX-toX >1)
7622                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_LEFT, ONE+fromY, AAA+toX+1,ONE+toY);
7623         }
7624         // e.p. suffix
7625         if( (boards[forwardMostMove][fromY][fromX] == WhitePawn ||
7626              boards[forwardMostMove][fromY][fromX] == BlackPawn   ) &&
7627              boards[forwardMostMove][toY][toX] == EmptySquare
7628              && fromX != toX )
7629                 fprintf(serverMoves, ":%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+fromY);
7630         // promotion suffix
7631         if(promoChar != NULLCHAR)
7632                 fprintf(serverMoves, ":%c:%c%c", promoChar, AAA+toX, ONE+toY);
7633         if(!loadFlag) {
7634             fprintf(serverMoves, "/%d/%d",
7635                pvInfoList[forwardMostMove].depth, pvInfoList[forwardMostMove].score);
7636             if(forwardMostMove+1 & 1) timeLeft = whiteTimeRemaining/1000;
7637             else                      timeLeft = blackTimeRemaining/1000;
7638             fprintf(serverMoves, "/%d", timeLeft);
7639         }
7640         fflush(serverMoves);
7641     }
7642
7643     if (forwardMostMove+1 >= MAX_MOVES) {
7644       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
7645                         0, 1);
7646       return;
7647     }
7648     if (commentList[forwardMostMove+1] != NULL) {
7649         free(commentList[forwardMostMove+1]);
7650         commentList[forwardMostMove+1] = NULL;
7651     }
7652     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
7653     {int i; for(i=0; i<BOARD_SIZE; i++) castlingRights[forwardMostMove+1][i] = castlingRights[forwardMostMove][i];}
7654     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[forwardMostMove+1],
7655                                 castlingRights[forwardMostMove+1], &epStatus[forwardMostMove+1]);
7656     forwardMostMove++; // [HGM] bare: moved to after ApplyMove, to make sure clock interrupt finds complete board
7657     SwitchClocks(); // uses forwardMostMove, so must be done after incrementing it !
7658     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
7659     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
7660     gameInfo.result = GameUnfinished;
7661     if (gameInfo.resultDetails != NULL) {
7662         free(gameInfo.resultDetails);
7663         gameInfo.resultDetails = NULL;
7664     }
7665     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar,
7666                               moveList[forwardMostMove - 1]);
7667     (void) CoordsToAlgebraic(boards[forwardMostMove - 1],
7668                              PosFlags(forwardMostMove - 1), EP_UNKNOWN,
7669                              fromY, fromX, toY, toX, promoChar,
7670                              parseList[forwardMostMove - 1]);
7671     switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove),
7672                        epStatus[forwardMostMove], /* [HGM] use true e.p. */
7673                             castlingRights[forwardMostMove]) ) {
7674       case MT_NONE:
7675       case MT_STALEMATE:
7676       default:
7677         break;
7678       case MT_CHECK:
7679         if(gameInfo.variant != VariantShogi)
7680             strcat(parseList[forwardMostMove - 1], "+");
7681         break;
7682       case MT_CHECKMATE:
7683       case MT_STAINMATE:
7684         strcat(parseList[forwardMostMove - 1], "#");
7685         break;
7686     }
7687     if (appData.debugMode) {
7688         fprintf(debugFP, "move: %s, parse: %s (%c)\n", moveList[forwardMostMove-1], parseList[forwardMostMove-1], moveList[forwardMostMove-1][4]);
7689     }
7690
7691 }
7692
7693 /* Updates currentMove if not pausing */
7694 void
7695 ShowMove(fromX, fromY, toX, toY)
7696 {
7697     int instant = (gameMode == PlayFromGameFile) ?
7698         (matchMode || (appData.timeDelay == 0 && !pausing)) : pausing;
7699     if(appData.noGUI) return;
7700     if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
7701         if (!instant) {
7702             if (forwardMostMove == currentMove + 1) {
7703                 AnimateMove(boards[forwardMostMove - 1],
7704                             fromX, fromY, toX, toY);
7705             }
7706             if (appData.highlightLastMove) {
7707                 SetHighlights(fromX, fromY, toX, toY);
7708             }
7709         }
7710         currentMove = forwardMostMove;
7711     }
7712
7713     if (instant) return;
7714
7715     DisplayMove(currentMove - 1);
7716     DrawPosition(FALSE, boards[currentMove]);
7717     DisplayBothClocks();
7718     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
7719 }
7720
7721 void SendEgtPath(ChessProgramState *cps)
7722 {       /* [HGM] EGT: match formats given in feature with those given by user, and send info for each match */
7723         char buf[MSG_SIZ], name[MSG_SIZ], *p;
7724
7725         if((p = cps->egtFormats) == NULL || appData.egtFormats == NULL) return;
7726
7727         while(*p) {
7728             char c, *q = name+1, *r, *s;
7729
7730             name[0] = ','; // extract next format name from feature and copy with prefixed ','
7731             while(*p && *p != ',') *q++ = *p++;
7732             *q++ = ':'; *q = 0;
7733             if( appData.defaultPathEGTB && appData.defaultPathEGTB[0] &&
7734                 strcmp(name, ",nalimov:") == 0 ) {
7735                 // take nalimov path from the menu-changeable option first, if it is defined
7736                 sprintf(buf, "egtpath nalimov %s\n", appData.defaultPathEGTB);
7737                 SendToProgram(buf,cps);     // send egtbpath command for nalimov
7738             } else
7739             if( (s = StrStr(appData.egtFormats, name+1)) == appData.egtFormats ||
7740                 (s = StrStr(appData.egtFormats, name)) != NULL) {
7741                 // format name occurs amongst user-supplied formats, at beginning or immediately after comma
7742                 s = r = StrStr(s, ":") + 1; // beginning of path info
7743                 while(*r && *r != ',') r++; // path info is everything upto next ';' or end of string
7744                 c = *r; *r = 0;             // temporarily null-terminate path info
7745                     *--q = 0;               // strip of trailig ':' from name
7746                     sprintf(buf, "egtpath %s %s\n", name+1, s);
7747                 *r = c;
7748                 SendToProgram(buf,cps);     // send egtbpath command for this format
7749             }
7750             if(*p == ',') p++; // read away comma to position for next format name
7751         }
7752 }
7753
7754 void
7755 InitChessProgram(cps, setup)
7756      ChessProgramState *cps;
7757      int setup; /* [HGM] needed to setup FRC opening position */
7758 {
7759     char buf[MSG_SIZ], b[MSG_SIZ]; int overruled;
7760     if (appData.noChessProgram) return;
7761     hintRequested = FALSE;
7762     bookRequested = FALSE;
7763
7764     /* [HGM] some new WB protocol commands to configure engine are sent now, if engine supports them */
7765     /*       moved to before sending initstring in 4.3.15, so Polyglot can delay UCI 'isready' to recepton of 'new' */
7766     if(cps->memSize) { /* [HGM] memory */
7767         sprintf(buf, "memory %d\n", appData.defaultHashSize + appData.defaultCacheSizeEGTB);
7768         SendToProgram(buf, cps);
7769     }
7770     SendEgtPath(cps); /* [HGM] EGT */
7771     if(cps->maxCores) { /* [HGM] SMP: (protocol specified must be last settings command before new!) */
7772         sprintf(buf, "cores %d\n", appData.smpCores);
7773         SendToProgram(buf, cps);
7774     }
7775
7776     SendToProgram(cps->initString, cps);
7777     if (gameInfo.variant != VariantNormal &&
7778         gameInfo.variant != VariantLoadable
7779         /* [HGM] also send variant if board size non-standard */
7780         || gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0
7781                                             ) {
7782       char *v = VariantName(gameInfo.variant);
7783       if (cps->protocolVersion != 1 && StrStr(cps->variants, v) == NULL) {
7784         /* [HGM] in protocol 1 we have to assume all variants valid */
7785         sprintf(buf, _("Variant %s not supported by %s"), v, cps->tidy);
7786         DisplayFatalError(buf, 0, 1);
7787         return;
7788       }
7789
7790       /* [HGM] make prefix for non-standard board size. Awkward testing... */
7791       overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
7792       if( gameInfo.variant == VariantXiangqi )
7793            overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 10 || gameInfo.holdingsSize != 0;
7794       if( gameInfo.variant == VariantShogi )
7795            overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 9 || gameInfo.holdingsSize != 7;
7796       if( gameInfo.variant == VariantBughouse || gameInfo.variant == VariantCrazyhouse )
7797            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 5;
7798       if( gameInfo.variant == VariantCapablanca || gameInfo.variant == VariantCapaRandom ||
7799                                gameInfo.variant == VariantGothic  || gameInfo.variant == VariantFalcon )
7800            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
7801       if( gameInfo.variant == VariantCourier )
7802            overruled = gameInfo.boardWidth != 12 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
7803       if( gameInfo.variant == VariantSuper )
7804            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
7805       if( gameInfo.variant == VariantGreat )
7806            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
7807
7808       if(overruled) {
7809            sprintf(b, "%dx%d+%d_%s", gameInfo.boardWidth, gameInfo.boardHeight,
7810                                gameInfo.holdingsSize, VariantName(gameInfo.variant)); // cook up sized variant name
7811            /* [HGM] varsize: try first if this defiant size variant is specifically known */
7812            if(StrStr(cps->variants, b) == NULL) {
7813                // specific sized variant not known, check if general sizing allowed
7814                if (cps->protocolVersion != 1) { // for protocol 1 we cannot check and hope for the best
7815                    if(StrStr(cps->variants, "boardsize") == NULL) {
7816                        sprintf(buf, "Board size %dx%d+%d not supported by %s",
7817                             gameInfo.boardWidth, gameInfo.boardHeight, gameInfo.holdingsSize, cps->tidy);
7818                        DisplayFatalError(buf, 0, 1);
7819                        return;
7820                    }
7821                    /* [HGM] here we really should compare with the maximum supported board size */
7822                }
7823            }
7824       } else sprintf(b, "%s", VariantName(gameInfo.variant));
7825       sprintf(buf, "variant %s\n", b);
7826       SendToProgram(buf, cps);
7827     }
7828     currentlyInitializedVariant = gameInfo.variant;
7829
7830     /* [HGM] send opening position in FRC to first engine */
7831     if(setup) {
7832           SendToProgram("force\n", cps);
7833           SendBoard(cps, 0);
7834           /* engine is now in force mode! Set flag to wake it up after first move. */
7835           setboardSpoiledMachineBlack = 1;
7836     }
7837
7838     if (cps->sendICS) {
7839       snprintf(buf, sizeof(buf), "ics %s\n", appData.icsActive ? appData.icsHost : "-");
7840       SendToProgram(buf, cps);
7841     }
7842     cps->maybeThinking = FALSE;
7843     cps->offeredDraw = 0;
7844     if (!appData.icsActive) {
7845         SendTimeControl(cps, movesPerSession, timeControl,
7846                         timeIncrement, appData.searchDepth,
7847                         searchTime);
7848     }
7849     if (appData.showThinking
7850         // [HGM] thinking: four options require thinking output to be sent
7851         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
7852                                 ) {
7853         SendToProgram("post\n", cps);
7854     }
7855     SendToProgram("hard\n", cps);
7856     if (!appData.ponderNextMove) {
7857         /* Warning: "easy" is a toggle in GNU Chess, so don't send
7858            it without being sure what state we are in first.  "hard"
7859            is not a toggle, so that one is OK.
7860          */
7861         SendToProgram("easy\n", cps);
7862     }
7863     if (cps->usePing) {
7864       sprintf(buf, "ping %d\n", ++cps->lastPing);
7865       SendToProgram(buf, cps);
7866     }
7867     cps->initDone = TRUE;
7868 }
7869
7870
7871 void
7872 StartChessProgram(cps)
7873      ChessProgramState *cps;
7874 {
7875     char buf[MSG_SIZ];
7876     int err;
7877
7878     if (appData.noChessProgram) return;
7879     cps->initDone = FALSE;
7880
7881     if (strcmp(cps->host, "localhost") == 0) {
7882         err = StartChildProcess(cps->program, cps->dir, &cps->pr);
7883     } else if (*appData.remoteShell == NULLCHAR) {
7884         err = OpenRcmd(cps->host, appData.remoteUser, cps->program, &cps->pr);
7885     } else {
7886         if (*appData.remoteUser == NULLCHAR) {
7887           snprintf(buf, sizeof(buf), "%s %s %s", appData.remoteShell, cps->host,
7888                     cps->program);
7889         } else {
7890           snprintf(buf, sizeof(buf), "%s %s -l %s %s", appData.remoteShell,
7891                     cps->host, appData.remoteUser, cps->program);
7892         }
7893         err = StartChildProcess(buf, "", &cps->pr);
7894     }
7895
7896     if (err != 0) {
7897         sprintf(buf, _("Startup failure on '%s'"), cps->program);
7898         DisplayFatalError(buf, err, 1);
7899         cps->pr = NoProc;
7900         cps->isr = NULL;
7901         return;
7902     }
7903
7904     cps->isr = AddInputSource(cps->pr, TRUE, ReceiveFromProgram, cps);
7905     if (cps->protocolVersion > 1) {
7906       sprintf(buf, "xboard\nprotover %d\n", cps->protocolVersion);
7907       cps->nrOptions = 0; // [HGM] options: clear all engine-specific options
7908       cps->comboCnt = 0;  //                and values of combo boxes
7909       SendToProgram(buf, cps);
7910     } else {
7911       SendToProgram("xboard\n", cps);
7912     }
7913 }
7914
7915
7916 void
7917 TwoMachinesEventIfReady P((void))
7918 {
7919   if (first.lastPing != first.lastPong) {
7920     DisplayMessage("", _("Waiting for first chess program"));
7921     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
7922     return;
7923   }
7924   if (second.lastPing != second.lastPong) {
7925     DisplayMessage("", _("Waiting for second chess program"));
7926     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
7927     return;
7928   }
7929   ThawUI();
7930   TwoMachinesEvent();
7931 }
7932
7933 void
7934 NextMatchGame P((void))
7935 {
7936     int index; /* [HGM] autoinc: step lod index during match */
7937     Reset(FALSE, TRUE);
7938     if (*appData.loadGameFile != NULLCHAR) {
7939         index = appData.loadGameIndex;
7940         if(index < 0) { // [HGM] autoinc
7941             lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
7942             if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
7943         }
7944         LoadGameFromFile(appData.loadGameFile,
7945                          index,
7946                          appData.loadGameFile, FALSE);
7947     } else if (*appData.loadPositionFile != NULLCHAR) {
7948         index = appData.loadPositionIndex;
7949         if(index < 0) { // [HGM] autoinc
7950             lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
7951             if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
7952         }
7953         LoadPositionFromFile(appData.loadPositionFile,
7954                              index,
7955                              appData.loadPositionFile);
7956     }
7957     TwoMachinesEventIfReady();
7958 }
7959
7960 void UserAdjudicationEvent( int result )
7961 {
7962     ChessMove gameResult = GameIsDrawn;
7963
7964     if( result > 0 ) {
7965         gameResult = WhiteWins;
7966     }
7967     else if( result < 0 ) {
7968         gameResult = BlackWins;
7969     }
7970
7971     if( gameMode == TwoMachinesPlay ) {
7972         GameEnds( gameResult, "User adjudication", GE_XBOARD );
7973     }
7974 }
7975
7976
7977 // [HGM] save: calculate checksum of game to make games easily identifiable
7978 int StringCheckSum(char *s)
7979 {
7980         int i = 0;
7981         if(s==NULL) return 0;
7982         while(*s) i = i*259 + *s++;
7983         return i;
7984 }
7985
7986 int GameCheckSum()
7987 {
7988         int i, sum=0;
7989         for(i=backwardMostMove; i<forwardMostMove; i++) {
7990                 sum += pvInfoList[i].depth;
7991                 sum += StringCheckSum(parseList[i]);
7992                 sum += StringCheckSum(commentList[i]);
7993                 sum *= 261;
7994         }
7995         if(i>1 && sum==0) sum++; // make sure never zero for non-empty game
7996         return sum + StringCheckSum(commentList[i]);
7997 } // end of save patch
7998
7999 void
8000 GameEnds(result, resultDetails, whosays)
8001      ChessMove result;
8002      char *resultDetails;
8003      int whosays;
8004 {
8005     GameMode nextGameMode;
8006     int isIcsGame;
8007     char buf[MSG_SIZ];
8008
8009     if(endingGame) return; /* [HGM] crash: forbid recursion */
8010     endingGame = 1;
8011
8012     if (appData.debugMode) {
8013       fprintf(debugFP, "GameEnds(%d, %s, %d)\n",
8014               result, resultDetails ? resultDetails : "(null)", whosays);
8015     }
8016
8017     if (appData.icsActive && (whosays == GE_ENGINE || whosays >= GE_ENGINE1)) {
8018         /* If we are playing on ICS, the server decides when the
8019            game is over, but the engine can offer to draw, claim
8020            a draw, or resign.
8021          */
8022 #if ZIPPY
8023         if (appData.zippyPlay && first.initDone) {
8024             if (result == GameIsDrawn) {
8025                 /* In case draw still needs to be claimed */
8026                 SendToICS(ics_prefix);
8027                 SendToICS("draw\n");
8028             } else if (StrCaseStr(resultDetails, "resign")) {
8029                 SendToICS(ics_prefix);
8030                 SendToICS("resign\n");
8031             }
8032         }
8033 #endif
8034         endingGame = 0; /* [HGM] crash */
8035         return;
8036     }
8037
8038     /* If we're loading the game from a file, stop */
8039     if (whosays == GE_FILE) {
8040       (void) StopLoadGameTimer();
8041       gameFileFP = NULL;
8042     }
8043
8044     /* Cancel draw offers */
8045     first.offeredDraw = second.offeredDraw = 0;
8046
8047     /* If this is an ICS game, only ICS can really say it's done;
8048        if not, anyone can. */
8049     isIcsGame = (gameMode == IcsPlayingWhite ||
8050                  gameMode == IcsPlayingBlack ||
8051                  gameMode == IcsObserving    ||
8052                  gameMode == IcsExamining);
8053
8054     if (!isIcsGame || whosays == GE_ICS) {
8055         /* OK -- not an ICS game, or ICS said it was done */
8056         StopClocks();
8057         if (!isIcsGame && !appData.noChessProgram)
8058           SetUserThinkingEnables();
8059
8060         /* [HGM] if a machine claims the game end we verify this claim */
8061         if(gameMode == TwoMachinesPlay && appData.testClaims) {
8062             if(appData.testLegality && whosays >= GE_ENGINE1 ) {
8063                 char claimer;
8064                 ChessMove trueResult = (ChessMove) -1;
8065
8066                 claimer = whosays == GE_ENGINE1 ?      /* color of claimer */
8067                                             first.twoMachinesColor[0] :
8068                                             second.twoMachinesColor[0] ;
8069
8070                 // [HGM] losers: because the logic is becoming a bit hairy, determine true result first
8071                 if(epStatus[forwardMostMove] == EP_CHECKMATE) {
8072                     /* [HGM] verify: engine mate claims accepted if they were flagged */
8073                     trueResult = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins;
8074                 } else
8075                 if(epStatus[forwardMostMove] == EP_WINS) { // added code for games where being mated is a win
8076                     /* [HGM] verify: engine mate claims accepted if they were flagged */
8077                     trueResult = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
8078                 } else
8079                 if(epStatus[forwardMostMove] == EP_STALEMATE) { // only used to indicate draws now
8080                     trueResult = GameIsDrawn; // default; in variants where stalemate loses, Status is CHECKMATE
8081                 }
8082
8083                 // now verify win claims, but not in drop games, as we don't understand those yet
8084                 if( (gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
8085                                                  || gameInfo.variant == VariantGreat) &&
8086                     (result == WhiteWins && claimer == 'w' ||
8087                      result == BlackWins && claimer == 'b'   ) ) { // case to verify: engine claims own win
8088                       if (appData.debugMode) {
8089                         fprintf(debugFP, "result=%d sp=%d move=%d\n",
8090                                 result, epStatus[forwardMostMove], forwardMostMove);
8091                       }
8092                       if(result != trueResult) {
8093                               sprintf(buf, "False win claim: '%s'", resultDetails);
8094                               result = claimer == 'w' ? BlackWins : WhiteWins;
8095                               resultDetails = buf;
8096                       }
8097                 } else
8098                 if( result == GameIsDrawn && epStatus[forwardMostMove] > EP_DRAWS
8099                     && (forwardMostMove <= backwardMostMove ||
8100                         epStatus[forwardMostMove-1] > EP_DRAWS ||
8101                         (claimer=='b')==(forwardMostMove&1))
8102                                                                                   ) {
8103                       /* [HGM] verify: draws that were not flagged are false claims */
8104                       sprintf(buf, "False draw claim: '%s'", resultDetails);
8105                       result = claimer == 'w' ? BlackWins : WhiteWins;
8106                       resultDetails = buf;
8107                 }
8108                 /* (Claiming a loss is accepted no questions asked!) */
8109             }
8110             /* [HGM] bare: don't allow bare King to win */
8111             if((gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
8112                && gameInfo.variant != VariantLosers && gameInfo.variant != VariantGiveaway
8113                && gameInfo.variant != VariantSuicide // [HGM] losers: except in losers, of course...
8114                && result != GameIsDrawn)
8115             {   int i, j, k=0, color = (result==WhiteWins ? (int)WhitePawn : (int)BlackPawn);
8116                 for(j=BOARD_LEFT; j<BOARD_RGHT; j++) for(i=0; i<BOARD_HEIGHT; i++) {
8117                         int p = (int)boards[forwardMostMove][i][j] - color;
8118                         if(p >= 0 && p <= (int)WhiteKing) k++;
8119                 }
8120                 if (appData.debugMode) {
8121                      fprintf(debugFP, "GE(%d, %s, %d) bare king k=%d color=%d\n",
8122                         result, resultDetails ? resultDetails : "(null)", whosays, k, color);
8123                 }
8124                 if(k <= 1) {
8125                         result = GameIsDrawn;
8126                         sprintf(buf, "%s but bare king", resultDetails);
8127                         resultDetails = buf;
8128                 }
8129             }
8130         }
8131
8132
8133         if(serverMoves != NULL && !loadFlag) { char c = '=';
8134             if(result==WhiteWins) c = '+';
8135             if(result==BlackWins) c = '-';
8136             if(resultDetails != NULL)
8137                 fprintf(serverMoves, ";%c;%s\n", c, resultDetails);
8138         }
8139         if (resultDetails != NULL) {
8140             gameInfo.result = result;
8141             gameInfo.resultDetails = StrSave(resultDetails);
8142
8143             /* display last move only if game was not loaded from file */
8144             if ((whosays != GE_FILE) && (currentMove == forwardMostMove))
8145                 DisplayMove(currentMove - 1);
8146
8147             if (forwardMostMove != 0) {
8148                 if (gameMode != PlayFromGameFile && gameMode != EditGame
8149                     && lastSavedGame != GameCheckSum() // [HGM] save: suppress duplicates
8150                                                                 ) {
8151                     if (*appData.saveGameFile != NULLCHAR) {
8152                         SaveGameToFile(appData.saveGameFile, TRUE);
8153                     } else if (appData.autoSaveGames) {
8154                         AutoSaveGame();
8155                     }
8156                     if (*appData.savePositionFile != NULLCHAR) {
8157                         SavePositionToFile(appData.savePositionFile);
8158                     }
8159                 }
8160             }
8161
8162             /* Tell program how game ended in case it is learning */
8163             /* [HGM] Moved this to after saving the PGN, just in case */
8164             /* engine died and we got here through time loss. In that */
8165             /* case we will get a fatal error writing the pipe, which */
8166             /* would otherwise lose us the PGN.                       */
8167             /* [HGM] crash: not needed anymore, but doesn't hurt;     */
8168             /* output during GameEnds should never be fatal anymore   */
8169             if (gameMode == MachinePlaysWhite ||
8170                 gameMode == MachinePlaysBlack ||
8171                 gameMode == TwoMachinesPlay ||
8172                 gameMode == IcsPlayingWhite ||
8173                 gameMode == IcsPlayingBlack ||
8174                 gameMode == BeginningOfGame) {
8175                 char buf[MSG_SIZ];
8176                 sprintf(buf, "result %s {%s}\n", PGNResult(result),
8177                         resultDetails);
8178                 if (first.pr != NoProc) {
8179                     SendToProgram(buf, &first);
8180                 }
8181                 if (second.pr != NoProc &&
8182                     gameMode == TwoMachinesPlay) {
8183                     SendToProgram(buf, &second);
8184                 }
8185             }
8186         }
8187
8188         if (appData.icsActive) {
8189             if (appData.quietPlay &&
8190                 (gameMode == IcsPlayingWhite ||
8191                  gameMode == IcsPlayingBlack)) {
8192                 SendToICS(ics_prefix);
8193                 SendToICS("set shout 1\n");
8194             }
8195             nextGameMode = IcsIdle;
8196             ics_user_moved = FALSE;
8197             /* clean up premove.  It's ugly when the game has ended and the
8198              * premove highlights are still on the board.
8199              */
8200             if (gotPremove) {
8201               gotPremove = FALSE;
8202               ClearPremoveHighlights();
8203               DrawPosition(FALSE, boards[currentMove]);
8204             }
8205             if (whosays == GE_ICS) {
8206                 switch (result) {
8207                 case WhiteWins:
8208                     if (gameMode == IcsPlayingWhite)
8209                         PlayIcsWinSound();
8210                     else if(gameMode == IcsPlayingBlack)
8211                         PlayIcsLossSound();
8212                     break;
8213                 case BlackWins:
8214                     if (gameMode == IcsPlayingBlack)
8215                         PlayIcsWinSound();
8216                     else if(gameMode == IcsPlayingWhite)
8217                         PlayIcsLossSound();
8218                     break;
8219                 case GameIsDrawn:
8220                     PlayIcsDrawSound();
8221                     break;
8222                 default:
8223                     PlayIcsUnfinishedSound();
8224                 }
8225             }
8226         } else if (gameMode == EditGame ||
8227                    gameMode == PlayFromGameFile ||
8228                    gameMode == AnalyzeMode ||
8229                    gameMode == AnalyzeFile) {
8230             nextGameMode = gameMode;
8231         } else {
8232             nextGameMode = EndOfGame;
8233         }
8234         pausing = FALSE;
8235         ModeHighlight();
8236     } else {
8237         nextGameMode = gameMode;
8238     }
8239
8240     if (appData.noChessProgram) {
8241         gameMode = nextGameMode;
8242         ModeHighlight();
8243         endingGame = 0; /* [HGM] crash */
8244         return;
8245     }
8246
8247     if (first.reuse) {
8248         /* Put first chess program into idle state */
8249         if (first.pr != NoProc &&
8250             (gameMode == MachinePlaysWhite ||
8251              gameMode == MachinePlaysBlack ||
8252              gameMode == TwoMachinesPlay ||
8253              gameMode == IcsPlayingWhite ||
8254              gameMode == IcsPlayingBlack ||
8255              gameMode == BeginningOfGame)) {
8256             SendToProgram("force\n", &first);
8257             if (first.usePing) {
8258               char buf[MSG_SIZ];
8259               sprintf(buf, "ping %d\n", ++first.lastPing);
8260               SendToProgram(buf, &first);
8261             }
8262         }
8263     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
8264         /* Kill off first chess program */
8265         if (first.isr != NULL)
8266           RemoveInputSource(first.isr);
8267         first.isr = NULL;
8268
8269         if (first.pr != NoProc) {
8270             ExitAnalyzeMode();
8271             DoSleep( appData.delayBeforeQuit );
8272             SendToProgram("quit\n", &first);
8273             DoSleep( appData.delayAfterQuit );
8274             DestroyChildProcess(first.pr, first.useSigterm);
8275         }
8276         first.pr = NoProc;
8277     }
8278     if (second.reuse) {
8279         /* Put second chess program into idle state */
8280         if (second.pr != NoProc &&
8281             gameMode == TwoMachinesPlay) {
8282             SendToProgram("force\n", &second);
8283             if (second.usePing) {
8284               char buf[MSG_SIZ];
8285               sprintf(buf, "ping %d\n", ++second.lastPing);
8286               SendToProgram(buf, &second);
8287             }
8288         }
8289     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
8290         /* Kill off second chess program */
8291         if (second.isr != NULL)
8292           RemoveInputSource(second.isr);
8293         second.isr = NULL;
8294
8295         if (second.pr != NoProc) {
8296             DoSleep( appData.delayBeforeQuit );
8297             SendToProgram("quit\n", &second);
8298             DoSleep( appData.delayAfterQuit );
8299             DestroyChildProcess(second.pr, second.useSigterm);
8300         }
8301         second.pr = NoProc;
8302     }
8303
8304     if (matchMode && gameMode == TwoMachinesPlay) {
8305         switch (result) {
8306         case WhiteWins:
8307           if (first.twoMachinesColor[0] == 'w') {
8308             first.matchWins++;
8309           } else {
8310             second.matchWins++;
8311           }
8312           break;
8313         case BlackWins:
8314           if (first.twoMachinesColor[0] == 'b') {
8315             first.matchWins++;
8316           } else {
8317             second.matchWins++;
8318           }
8319           break;
8320         default:
8321           break;
8322         }
8323         if (matchGame < appData.matchGames) {
8324             char *tmp;
8325             if(appData.sameColorGames <= 1) { /* [HGM] alternate: suppress color swap */
8326                 tmp = first.twoMachinesColor;
8327                 first.twoMachinesColor = second.twoMachinesColor;
8328                 second.twoMachinesColor = tmp;
8329             }
8330             gameMode = nextGameMode;
8331             matchGame++;
8332             if(appData.matchPause>10000 || appData.matchPause<10)
8333                 appData.matchPause = 10000; /* [HGM] make pause adjustable */
8334             ScheduleDelayedEvent(NextMatchGame, appData.matchPause);
8335             endingGame = 0; /* [HGM] crash */
8336             return;
8337         } else {
8338             char buf[MSG_SIZ];
8339             gameMode = nextGameMode;
8340             sprintf(buf, _("Match %s vs. %s: final score %d-%d-%d"),
8341                     first.tidy, second.tidy,
8342                     first.matchWins, second.matchWins,
8343                     appData.matchGames - (first.matchWins + second.matchWins));
8344             DisplayFatalError(buf, 0, 0);
8345         }
8346     }
8347     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile) &&
8348         !(nextGameMode == AnalyzeMode || nextGameMode == AnalyzeFile))
8349       ExitAnalyzeMode();
8350     gameMode = nextGameMode;
8351     ModeHighlight();
8352     endingGame = 0;  /* [HGM] crash */
8353 }
8354
8355 /* Assumes program was just initialized (initString sent).
8356    Leaves program in force mode. */
8357 void
8358 FeedMovesToProgram(cps, upto)
8359      ChessProgramState *cps;
8360      int upto;
8361 {
8362     int i;
8363
8364     if (appData.debugMode)
8365       fprintf(debugFP, "Feeding %smoves %d through %d to %s chess program\n",
8366               startedFromSetupPosition ? "position and " : "",
8367               backwardMostMove, upto, cps->which);
8368     if(currentlyInitializedVariant != gameInfo.variant) { char buf[MSG_SIZ];
8369         // [HGM] variantswitch: make engine aware of new variant
8370         if(cps->protocolVersion > 1 && StrStr(cps->variants, VariantName(gameInfo.variant)) == NULL)
8371                 return; // [HGM] refrain from feeding moves altogether if variant is unsupported!
8372         sprintf(buf, "variant %s\n", VariantName(gameInfo.variant));
8373         SendToProgram(buf, cps);
8374         currentlyInitializedVariant = gameInfo.variant;
8375     }
8376     SendToProgram("force\n", cps);
8377     if (startedFromSetupPosition) {
8378         SendBoard(cps, backwardMostMove);
8379     if (appData.debugMode) {
8380         fprintf(debugFP, "feedMoves\n");
8381     }
8382     }
8383     for (i = backwardMostMove; i < upto; i++) {
8384         SendMoveToProgram(i, cps);
8385     }
8386 }
8387
8388
8389 void
8390 ResurrectChessProgram()
8391 {
8392      /* The chess program may have exited.
8393         If so, restart it and feed it all the moves made so far. */
8394
8395     if (appData.noChessProgram || first.pr != NoProc) return;
8396
8397     StartChessProgram(&first);
8398     InitChessProgram(&first, FALSE);
8399     FeedMovesToProgram(&first, currentMove);
8400
8401     if (!first.sendTime) {
8402         /* can't tell gnuchess what its clock should read,
8403            so we bow to its notion. */
8404         ResetClocks();
8405         timeRemaining[0][currentMove] = whiteTimeRemaining;
8406         timeRemaining[1][currentMove] = blackTimeRemaining;
8407     }
8408
8409     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile ||
8410                 appData.icsEngineAnalyze) && first.analysisSupport) {
8411       SendToProgram("analyze\n", &first);
8412       first.analyzing = TRUE;
8413     }
8414 }
8415
8416 /*
8417  * Button procedures
8418  */
8419 void
8420 Reset(redraw, init)
8421      int redraw, init;
8422 {
8423     int i;
8424
8425     if (appData.debugMode) {
8426         fprintf(debugFP, "Reset(%d, %d) from gameMode %d\n",
8427                 redraw, init, gameMode);
8428     }
8429     pausing = pauseExamInvalid = FALSE;
8430     startedFromSetupPosition = blackPlaysFirst = FALSE;
8431     firstMove = TRUE;
8432     whiteFlag = blackFlag = FALSE;
8433     userOfferedDraw = FALSE;
8434     hintRequested = bookRequested = FALSE;
8435     first.maybeThinking = FALSE;
8436     second.maybeThinking = FALSE;
8437     first.bookSuspend = FALSE; // [HGM] book
8438     second.bookSuspend = FALSE;
8439     thinkOutput[0] = NULLCHAR;
8440     lastHint[0] = NULLCHAR;
8441     ClearGameInfo(&gameInfo);
8442     gameInfo.variant = StringToVariant(appData.variant);
8443     ics_user_moved = ics_clock_paused = FALSE;
8444     ics_getting_history = H_FALSE;
8445     ics_gamenum = -1;
8446     white_holding[0] = black_holding[0] = NULLCHAR;
8447     ClearProgramStats();
8448     opponentKibitzes = FALSE; // [HGM] kibitz: do not reserve space in engine-output window in zippy mode
8449
8450     ResetFrontEnd();
8451     ClearHighlights();
8452     flipView = appData.flipView;
8453     ClearPremoveHighlights();
8454     gotPremove = FALSE;
8455     alarmSounded = FALSE;
8456
8457     GameEnds((ChessMove) 0, NULL, GE_PLAYER);
8458     if(appData.serverMovesName != NULL) {
8459         /* [HGM] prepare to make moves file for broadcasting */
8460         clock_t t = clock();
8461         if(serverMoves != NULL) fclose(serverMoves);
8462         serverMoves = fopen(appData.serverMovesName, "r");
8463         if(serverMoves != NULL) {
8464             fclose(serverMoves);
8465             /* delay 15 sec before overwriting, so all clients can see end */
8466             while(clock()-t < appData.serverPause*CLOCKS_PER_SEC);
8467         }
8468         serverMoves = fopen(appData.serverMovesName, "w");
8469     }
8470
8471     ExitAnalyzeMode();
8472     gameMode = BeginningOfGame;
8473     ModeHighlight();
8474     if(appData.icsActive) gameInfo.variant = VariantNormal;
8475     currentMove = forwardMostMove = backwardMostMove = 0;
8476     InitPosition(redraw);
8477     for (i = 0; i < MAX_MOVES; i++) {
8478         if (commentList[i] != NULL) {
8479             free(commentList[i]);
8480             commentList[i] = NULL;
8481         }
8482     }
8483     ResetClocks();
8484     timeRemaining[0][0] = whiteTimeRemaining;
8485     timeRemaining[1][0] = blackTimeRemaining;
8486     if (first.pr == NULL) {
8487         StartChessProgram(&first);
8488     }
8489     if (init) {
8490             InitChessProgram(&first, startedFromSetupPosition);
8491     }
8492     DisplayTitle("");
8493     DisplayMessage("", "");
8494     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
8495     lastSavedGame = 0; // [HGM] save: make sure next game counts as unsaved
8496 }
8497
8498 void
8499 AutoPlayGameLoop()
8500 {
8501     for (;;) {
8502         if (!AutoPlayOneMove())
8503           return;
8504         if (matchMode || appData.timeDelay == 0)
8505           continue;
8506         if (appData.timeDelay < 0 || gameMode == AnalyzeFile)
8507           return;
8508         StartLoadGameTimer((long)(1000.0 * appData.timeDelay));
8509         break;
8510     }
8511 }
8512
8513
8514 int
8515 AutoPlayOneMove()
8516 {
8517     int fromX, fromY, toX, toY;
8518
8519     if (appData.debugMode) {
8520       fprintf(debugFP, "AutoPlayOneMove(): current %d\n", currentMove);
8521     }
8522
8523     if (gameMode != PlayFromGameFile)
8524       return FALSE;
8525
8526     if (currentMove >= forwardMostMove) {
8527       gameMode = EditGame;
8528       ModeHighlight();
8529
8530       /* [AS] Clear current move marker at the end of a game */
8531       /* HistorySet(parseList, backwardMostMove, forwardMostMove, -1); */
8532
8533       return FALSE;
8534     }
8535
8536     toX = moveList[currentMove][2] - AAA;
8537     toY = moveList[currentMove][3] - ONE;
8538
8539     if (moveList[currentMove][1] == '@') {
8540         if (appData.highlightLastMove) {
8541             SetHighlights(-1, -1, toX, toY);
8542         }
8543     } else {
8544         fromX = moveList[currentMove][0] - AAA;
8545         fromY = moveList[currentMove][1] - ONE;
8546
8547         HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove); /* [AS] */
8548
8549         AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
8550
8551         if (appData.highlightLastMove) {
8552             SetHighlights(fromX, fromY, toX, toY);
8553         }
8554     }
8555     DisplayMove(currentMove);
8556     SendMoveToProgram(currentMove++, &first);
8557     DisplayBothClocks();
8558     DrawPosition(FALSE, boards[currentMove]);
8559     // [HGM] PV info: always display, routine tests if empty
8560     DisplayComment(currentMove - 1, commentList[currentMove]);
8561     return TRUE;
8562 }
8563
8564
8565 int
8566 LoadGameOneMove(readAhead)
8567      ChessMove readAhead;
8568 {
8569     int fromX = 0, fromY = 0, toX = 0, toY = 0, done;
8570     char promoChar = NULLCHAR;
8571     ChessMove moveType;
8572     char move[MSG_SIZ];
8573     char *p, *q;
8574
8575     if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile &&
8576         gameMode != AnalyzeMode && gameMode != Training) {
8577         gameFileFP = NULL;
8578         return FALSE;
8579     }
8580
8581     yyboardindex = forwardMostMove;
8582     if (readAhead != (ChessMove)0) {
8583       moveType = readAhead;
8584     } else {
8585       if (gameFileFP == NULL)
8586           return FALSE;
8587       moveType = (ChessMove) yylex();
8588     }
8589
8590     done = FALSE;
8591     switch (moveType) {
8592       case Comment:
8593         if (appData.debugMode)
8594           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
8595         p = yy_text;
8596         if (*p == '{' || *p == '[' || *p == '(') {
8597             p[strlen(p) - 1] = NULLCHAR;
8598             p++;
8599         }
8600
8601         /* append the comment but don't display it */
8602         while (*p == '\n') p++;
8603         AppendComment(currentMove, p);
8604         return TRUE;
8605
8606       case WhiteCapturesEnPassant:
8607       case BlackCapturesEnPassant:
8608       case WhitePromotionChancellor:
8609       case BlackPromotionChancellor:
8610       case WhitePromotionArchbishop:
8611       case BlackPromotionArchbishop:
8612       case WhitePromotionCentaur:
8613       case BlackPromotionCentaur:
8614       case WhitePromotionQueen:
8615       case BlackPromotionQueen:
8616       case WhitePromotionRook:
8617       case BlackPromotionRook:
8618       case WhitePromotionBishop:
8619       case BlackPromotionBishop:
8620       case WhitePromotionKnight:
8621       case BlackPromotionKnight:
8622       case WhitePromotionKing:
8623       case BlackPromotionKing:
8624       case NormalMove:
8625       case WhiteKingSideCastle:
8626       case WhiteQueenSideCastle:
8627       case BlackKingSideCastle:
8628       case BlackQueenSideCastle:
8629       case WhiteKingSideCastleWild:
8630       case WhiteQueenSideCastleWild:
8631       case BlackKingSideCastleWild:
8632       case BlackQueenSideCastleWild:
8633       /* PUSH Fabien */
8634       case WhiteHSideCastleFR:
8635       case WhiteASideCastleFR:
8636       case BlackHSideCastleFR:
8637       case BlackASideCastleFR:
8638       /* POP Fabien */
8639         if (appData.debugMode)
8640           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
8641         fromX = currentMoveString[0] - AAA;
8642         fromY = currentMoveString[1] - ONE;
8643         toX = currentMoveString[2] - AAA;
8644         toY = currentMoveString[3] - ONE;
8645         promoChar = currentMoveString[4];
8646         break;
8647
8648       case WhiteDrop:
8649       case BlackDrop:
8650         if (appData.debugMode)
8651           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
8652         fromX = moveType == WhiteDrop ?
8653           (int) CharToPiece(ToUpper(currentMoveString[0])) :
8654         (int) CharToPiece(ToLower(currentMoveString[0]));
8655         fromY = DROP_RANK;
8656         toX = currentMoveString[2] - AAA;
8657         toY = currentMoveString[3] - ONE;
8658         break;
8659
8660       case WhiteWins:
8661       case BlackWins:
8662       case GameIsDrawn:
8663       case GameUnfinished:
8664         if (appData.debugMode)
8665           fprintf(debugFP, "Parsed game end: %s\n", yy_text);
8666         p = strchr(yy_text, '{');
8667         if (p == NULL) p = strchr(yy_text, '(');
8668         if (p == NULL) {
8669             p = yy_text;
8670             if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
8671         } else {
8672             q = strchr(p, *p == '{' ? '}' : ')');
8673             if (q != NULL) *q = NULLCHAR;
8674             p++;
8675         }
8676         GameEnds(moveType, p, GE_FILE);
8677         done = TRUE;
8678         if (cmailMsgLoaded) {
8679             ClearHighlights();
8680             flipView = WhiteOnMove(currentMove);
8681             if (moveType == GameUnfinished) flipView = !flipView;
8682             if (appData.debugMode)
8683               fprintf(debugFP, "Setting flipView to %d\n", flipView) ;
8684         }
8685         break;
8686
8687       case (ChessMove) 0:       /* end of file */
8688         if (appData.debugMode)
8689           fprintf(debugFP, "Parser hit end of file\n");
8690         switch (MateTest(boards[currentMove], PosFlags(currentMove),
8691                          EP_UNKNOWN, castlingRights[currentMove]) ) {
8692           case MT_NONE:
8693           case MT_CHECK:
8694             break;
8695           case MT_CHECKMATE:
8696           case MT_STAINMATE:
8697             if (WhiteOnMove(currentMove)) {
8698                 GameEnds(BlackWins, "Black mates", GE_FILE);
8699             } else {
8700                 GameEnds(WhiteWins, "White mates", GE_FILE);
8701             }
8702             break;
8703           case MT_STALEMATE:
8704             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
8705             break;
8706         }
8707         done = TRUE;
8708         break;
8709
8710       case MoveNumberOne:
8711         if (lastLoadGameStart == GNUChessGame) {
8712             /* GNUChessGames have numbers, but they aren't move numbers */
8713             if (appData.debugMode)
8714               fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
8715                       yy_text, (int) moveType);
8716             return LoadGameOneMove((ChessMove)0); /* tail recursion */
8717         }
8718         /* else fall thru */
8719
8720       case XBoardGame:
8721       case GNUChessGame:
8722       case PGNTag:
8723         /* Reached start of next game in file */
8724         if (appData.debugMode)
8725           fprintf(debugFP, "Parsed start of next game: %s\n", yy_text);
8726         switch (MateTest(boards[currentMove], PosFlags(currentMove),
8727                          EP_UNKNOWN, castlingRights[currentMove]) ) {
8728           case MT_NONE:
8729           case MT_CHECK:
8730             break;
8731           case MT_CHECKMATE:
8732           case MT_STAINMATE:
8733             if (WhiteOnMove(currentMove)) {
8734                 GameEnds(BlackWins, "Black mates", GE_FILE);
8735             } else {
8736                 GameEnds(WhiteWins, "White mates", GE_FILE);
8737             }
8738             break;
8739           case MT_STALEMATE:
8740             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
8741             break;
8742         }
8743         done = TRUE;
8744         break;
8745
8746       case PositionDiagram:     /* should not happen; ignore */
8747       case ElapsedTime:         /* ignore */
8748       case NAG:                 /* ignore */
8749         if (appData.debugMode)
8750           fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
8751                   yy_text, (int) moveType);
8752         return LoadGameOneMove((ChessMove)0); /* tail recursion */
8753
8754       case IllegalMove:
8755         if (appData.testLegality) {
8756             if (appData.debugMode)
8757               fprintf(debugFP, "Parsed IllegalMove: %s\n", yy_text);
8758             sprintf(move, _("Illegal move: %d.%s%s"),
8759                     (forwardMostMove / 2) + 1,
8760                     WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
8761             DisplayError(move, 0);
8762             done = TRUE;
8763         } else {
8764             if (appData.debugMode)
8765               fprintf(debugFP, "Parsed %s into IllegalMove %s\n",
8766                       yy_text, currentMoveString);
8767             fromX = currentMoveString[0] - AAA;
8768             fromY = currentMoveString[1] - ONE;
8769             toX = currentMoveString[2] - AAA;
8770             toY = currentMoveString[3] - ONE;
8771             promoChar = currentMoveString[4];
8772         }
8773         break;
8774
8775       case AmbiguousMove:
8776         if (appData.debugMode)
8777           fprintf(debugFP, "Parsed AmbiguousMove: %s\n", yy_text);
8778         sprintf(move, _("Ambiguous move: %d.%s%s"),
8779                 (forwardMostMove / 2) + 1,
8780                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
8781         DisplayError(move, 0);
8782         done = TRUE;
8783         break;
8784
8785       default:
8786       case ImpossibleMove:
8787         if (appData.debugMode)
8788           fprintf(debugFP, "Parsed ImpossibleMove (type = %d): %s\n", moveType, yy_text);
8789         sprintf(move, _("Illegal move: %d.%s%s"),
8790                 (forwardMostMove / 2) + 1,
8791                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
8792         DisplayError(move, 0);
8793         done = TRUE;
8794         break;
8795     }
8796
8797     if (done) {
8798         if (appData.matchMode || (appData.timeDelay == 0 && !pausing)) {
8799             DrawPosition(FALSE, boards[currentMove]);
8800             DisplayBothClocks();
8801             if (!appData.matchMode) // [HGM] PV info: routine tests if empty
8802               DisplayComment(currentMove - 1, commentList[currentMove]);
8803         }
8804         (void) StopLoadGameTimer();
8805         gameFileFP = NULL;
8806         cmailOldMove = forwardMostMove;
8807         return FALSE;
8808     } else {
8809         /* currentMoveString is set as a side-effect of yylex */
8810         strcat(currentMoveString, "\n");
8811         strcpy(moveList[forwardMostMove], currentMoveString);
8812
8813         thinkOutput[0] = NULLCHAR;
8814         MakeMove(fromX, fromY, toX, toY, promoChar);
8815         currentMove = forwardMostMove;
8816         return TRUE;
8817     }
8818 }
8819
8820 /* Load the nth game from the given file */
8821 int
8822 LoadGameFromFile(filename, n, title, useList)
8823      char *filename;
8824      int n;
8825      char *title;
8826      /*Boolean*/ int useList;
8827 {
8828     FILE *f;
8829     char buf[MSG_SIZ];
8830
8831     if (strcmp(filename, "-") == 0) {
8832         f = stdin;
8833         title = "stdin";
8834     } else {
8835         f = fopen(filename, "rb");
8836         if (f == NULL) {
8837           snprintf(buf, sizeof(buf),  _("Can't open \"%s\""), filename);
8838             DisplayError(buf, errno);
8839             return FALSE;
8840         }
8841     }
8842     if (fseek(f, 0, 0) == -1) {
8843         /* f is not seekable; probably a pipe */
8844         useList = FALSE;
8845     }
8846     if (useList && n == 0) {
8847         int error = GameListBuild(f);
8848         if (error) {
8849             DisplayError(_("Cannot build game list"), error);
8850         } else if (!ListEmpty(&gameList) &&
8851                    ((ListGame *) gameList.tailPred)->number > 1) {
8852             GameListPopUp(f, title);
8853             return TRUE;
8854         }
8855         GameListDestroy();
8856         n = 1;
8857     }
8858     if (n == 0) n = 1;
8859     return LoadGame(f, n, title, FALSE);
8860 }
8861
8862
8863 void
8864 MakeRegisteredMove()
8865 {
8866     int fromX, fromY, toX, toY;
8867     char promoChar;
8868     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
8869         switch (cmailMoveType[lastLoadGameNumber - 1]) {
8870           case CMAIL_MOVE:
8871           case CMAIL_DRAW:
8872             if (appData.debugMode)
8873               fprintf(debugFP, "Restoring %s for game %d\n",
8874                       cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
8875
8876             thinkOutput[0] = NULLCHAR;
8877             strcpy(moveList[currentMove], cmailMove[lastLoadGameNumber - 1]);
8878             fromX = cmailMove[lastLoadGameNumber - 1][0] - AAA;
8879             fromY = cmailMove[lastLoadGameNumber - 1][1] - ONE;
8880             toX = cmailMove[lastLoadGameNumber - 1][2] - AAA;
8881             toY = cmailMove[lastLoadGameNumber - 1][3] - ONE;
8882             promoChar = cmailMove[lastLoadGameNumber - 1][4];
8883             MakeMove(fromX, fromY, toX, toY, promoChar);
8884             ShowMove(fromX, fromY, toX, toY);
8885
8886             switch (MateTest(boards[currentMove], PosFlags(currentMove),
8887                              EP_UNKNOWN, castlingRights[currentMove]) ) {
8888               case MT_NONE:
8889               case MT_CHECK:
8890                 break;
8891
8892               case MT_CHECKMATE:
8893               case MT_STAINMATE:
8894                 if (WhiteOnMove(currentMove)) {
8895                     GameEnds(BlackWins, "Black mates", GE_PLAYER);
8896                 } else {
8897                     GameEnds(WhiteWins, "White mates", GE_PLAYER);
8898                 }
8899                 break;
8900
8901               case MT_STALEMATE:
8902                 GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
8903                 break;
8904             }
8905
8906             break;
8907
8908           case CMAIL_RESIGN:
8909             if (WhiteOnMove(currentMove)) {
8910                 GameEnds(BlackWins, "White resigns", GE_PLAYER);
8911             } else {
8912                 GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
8913             }
8914             break;
8915
8916           case CMAIL_ACCEPT:
8917             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
8918             break;
8919
8920           default:
8921             break;
8922         }
8923     }
8924
8925     return;
8926 }
8927
8928 /* Wrapper around LoadGame for use when a Cmail message is loaded */
8929 int
8930 CmailLoadGame(f, gameNumber, title, useList)
8931      FILE *f;
8932      int gameNumber;
8933      char *title;
8934      int useList;
8935 {
8936     int retVal;
8937
8938     if (gameNumber > nCmailGames) {
8939         DisplayError(_("No more games in this message"), 0);
8940         return FALSE;
8941     }
8942     if (f == lastLoadGameFP) {
8943         int offset = gameNumber - lastLoadGameNumber;
8944         if (offset == 0) {
8945             cmailMsg[0] = NULLCHAR;
8946             if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
8947                 cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
8948                 nCmailMovesRegistered--;
8949             }
8950             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
8951             if (cmailResult[lastLoadGameNumber - 1] == CMAIL_NEW_RESULT) {
8952                 cmailResult[lastLoadGameNumber - 1] = CMAIL_NOT_RESULT;
8953             }
8954         } else {
8955             if (! RegisterMove()) return FALSE;
8956         }
8957     }
8958
8959     retVal = LoadGame(f, gameNumber, title, useList);
8960
8961     /* Make move registered during previous look at this game, if any */
8962     MakeRegisteredMove();
8963
8964     if (cmailCommentList[lastLoadGameNumber - 1] != NULL) {
8965         commentList[currentMove]
8966           = StrSave(cmailCommentList[lastLoadGameNumber - 1]);
8967         DisplayComment(currentMove - 1, commentList[currentMove]);
8968     }
8969
8970     return retVal;
8971 }
8972
8973 /* Support for LoadNextGame, LoadPreviousGame, ReloadSameGame */
8974 int
8975 ReloadGame(offset)
8976      int offset;
8977 {
8978     int gameNumber = lastLoadGameNumber + offset;
8979     if (lastLoadGameFP == NULL) {
8980         DisplayError(_("No game has been loaded yet"), 0);
8981         return FALSE;
8982     }
8983     if (gameNumber <= 0) {
8984         DisplayError(_("Can't back up any further"), 0);
8985         return FALSE;
8986     }
8987     if (cmailMsgLoaded) {
8988         return CmailLoadGame(lastLoadGameFP, gameNumber,
8989                              lastLoadGameTitle, lastLoadGameUseList);
8990     } else {
8991         return LoadGame(lastLoadGameFP, gameNumber,
8992                         lastLoadGameTitle, lastLoadGameUseList);
8993     }
8994 }
8995
8996
8997
8998 /* Load the nth game from open file f */
8999 int
9000 LoadGame(f, gameNumber, title, useList)
9001      FILE *f;
9002      int gameNumber;
9003      char *title;
9004      int useList;
9005 {
9006     ChessMove cm;
9007     char buf[MSG_SIZ];
9008     int gn = gameNumber;
9009     ListGame *lg = NULL;
9010     int numPGNTags = 0;
9011     int err;
9012     GameMode oldGameMode;
9013     VariantClass oldVariant = gameInfo.variant; /* [HGM] PGNvariant */
9014
9015     if (appData.debugMode)
9016         fprintf(debugFP, "LoadGame(): on entry, gameMode %d\n", gameMode);
9017
9018     if (gameMode == Training )
9019         SetTrainingModeOff();
9020
9021     oldGameMode = gameMode;
9022     if (gameMode != BeginningOfGame) {
9023       Reset(FALSE, TRUE);
9024     }
9025
9026     gameFileFP = f;
9027     if (lastLoadGameFP != NULL && lastLoadGameFP != f) {
9028         fclose(lastLoadGameFP);
9029     }
9030
9031     if (useList) {
9032         lg = (ListGame *) ListElem(&gameList, gameNumber-1);
9033
9034         if (lg) {
9035             fseek(f, lg->offset, 0);
9036             GameListHighlight(gameNumber);
9037             gn = 1;
9038         }
9039         else {
9040             DisplayError(_("Game number out of range"), 0);
9041             return FALSE;
9042         }
9043     } else {
9044         GameListDestroy();
9045         if (fseek(f, 0, 0) == -1) {
9046             if (f == lastLoadGameFP ?
9047                 gameNumber == lastLoadGameNumber + 1 :
9048                 gameNumber == 1) {
9049                 gn = 1;
9050             } else {
9051                 DisplayError(_("Can't seek on game file"), 0);
9052                 return FALSE;
9053             }
9054         }
9055     }
9056     lastLoadGameFP = f;
9057     lastLoadGameNumber = gameNumber;
9058     strcpy(lastLoadGameTitle, title);
9059     lastLoadGameUseList = useList;
9060
9061     yynewfile(f);
9062
9063     if (lg && lg->gameInfo.white && lg->gameInfo.black) {
9064       snprintf(buf, sizeof(buf), "%s vs. %s", lg->gameInfo.white,
9065                 lg->gameInfo.black);
9066             DisplayTitle(buf);
9067     } else if (*title != NULLCHAR) {
9068         if (gameNumber > 1) {
9069             sprintf(buf, "%s %d", title, gameNumber);
9070             DisplayTitle(buf);
9071         } else {
9072             DisplayTitle(title);
9073         }
9074     }
9075
9076     if (gameMode != AnalyzeFile && gameMode != AnalyzeMode) {
9077         gameMode = PlayFromGameFile;
9078         ModeHighlight();
9079     }
9080
9081     currentMove = forwardMostMove = backwardMostMove = 0;
9082     CopyBoard(boards[0], initialPosition);
9083     StopClocks();
9084
9085     /*
9086      * Skip the first gn-1 games in the file.
9087      * Also skip over anything that precedes an identifiable
9088      * start of game marker, to avoid being confused by
9089      * garbage at the start of the file.  Currently
9090      * recognized start of game markers are the move number "1",
9091      * the pattern "gnuchess .* game", the pattern
9092      * "^[#;%] [^ ]* game file", and a PGN tag block.
9093      * A game that starts with one of the latter two patterns
9094      * will also have a move number 1, possibly
9095      * following a position diagram.
9096      * 5-4-02: Let's try being more lenient and allowing a game to
9097      * start with an unnumbered move.  Does that break anything?
9098      */
9099     cm = lastLoadGameStart = (ChessMove) 0;
9100     while (gn > 0) {
9101         yyboardindex = forwardMostMove;
9102         cm = (ChessMove) yylex();
9103         switch (cm) {
9104           case (ChessMove) 0:
9105             if (cmailMsgLoaded) {
9106                 nCmailGames = CMAIL_MAX_GAMES - gn;
9107             } else {
9108                 Reset(TRUE, TRUE);
9109                 DisplayError(_("Game not found in file"), 0);
9110             }
9111             return FALSE;
9112
9113           case GNUChessGame:
9114           case XBoardGame:
9115             gn--;
9116             lastLoadGameStart = cm;
9117             break;
9118
9119           case MoveNumberOne:
9120             switch (lastLoadGameStart) {
9121               case GNUChessGame:
9122               case XBoardGame:
9123               case PGNTag:
9124                 break;
9125               case MoveNumberOne:
9126               case (ChessMove) 0:
9127                 gn--;           /* count this game */
9128                 lastLoadGameStart = cm;
9129                 break;
9130               default:
9131                 /* impossible */
9132                 break;
9133             }
9134             break;
9135
9136           case PGNTag:
9137             switch (lastLoadGameStart) {
9138               case GNUChessGame:
9139               case PGNTag:
9140               case MoveNumberOne:
9141               case (ChessMove) 0:
9142                 gn--;           /* count this game */
9143                 lastLoadGameStart = cm;
9144                 break;
9145               case XBoardGame:
9146                 lastLoadGameStart = cm; /* game counted already */
9147                 break;
9148               default:
9149                 /* impossible */
9150                 break;
9151             }
9152             if (gn > 0) {
9153                 do {
9154                     yyboardindex = forwardMostMove;
9155                     cm = (ChessMove) yylex();
9156                 } while (cm == PGNTag || cm == Comment);
9157             }
9158             break;
9159
9160           case WhiteWins:
9161           case BlackWins:
9162           case GameIsDrawn:
9163             if (cmailMsgLoaded && (CMAIL_MAX_GAMES == lastLoadGameNumber)) {
9164                 if (   cmailResult[CMAIL_MAX_GAMES - gn - 1]
9165                     != CMAIL_OLD_RESULT) {
9166                     nCmailResults ++ ;
9167                     cmailResult[  CMAIL_MAX_GAMES
9168                                 - gn - 1] = CMAIL_OLD_RESULT;
9169                 }
9170             }
9171             break;
9172
9173           case NormalMove:
9174             /* Only a NormalMove can be at the start of a game
9175              * without a position diagram. */
9176             if (lastLoadGameStart == (ChessMove) 0) {
9177               gn--;
9178               lastLoadGameStart = MoveNumberOne;
9179             }
9180             break;
9181
9182           default:
9183             break;
9184         }
9185     }
9186
9187     if (appData.debugMode)
9188       fprintf(debugFP, "Parsed game start '%s' (%d)\n", yy_text, (int) cm);
9189
9190     if (cm == XBoardGame) {
9191         /* Skip any header junk before position diagram and/or move 1 */
9192         for (;;) {
9193             yyboardindex = forwardMostMove;
9194             cm = (ChessMove) yylex();
9195
9196             if (cm == (ChessMove) 0 ||
9197                 cm == GNUChessGame || cm == XBoardGame) {
9198                 /* Empty game; pretend end-of-file and handle later */
9199                 cm = (ChessMove) 0;
9200                 break;
9201             }
9202
9203             if (cm == MoveNumberOne || cm == PositionDiagram ||
9204                 cm == PGNTag || cm == Comment)
9205               break;
9206         }
9207     } else if (cm == GNUChessGame) {
9208         if (gameInfo.event != NULL) {
9209             free(gameInfo.event);
9210         }
9211         gameInfo.event = StrSave(yy_text);
9212     }
9213
9214     startedFromSetupPosition = FALSE;
9215     while (cm == PGNTag) {
9216         if (appData.debugMode)
9217           fprintf(debugFP, "Parsed PGNTag: %s\n", yy_text);
9218         err = ParsePGNTag(yy_text, &gameInfo);
9219         if (!err) numPGNTags++;
9220
9221         /* [HGM] PGNvariant: automatically switch to variant given in PGN tag */
9222         if(gameInfo.variant != oldVariant) {
9223             startedFromPositionFile = FALSE; /* [HGM] loadPos: variant switch likely makes position invalid */
9224             InitPosition(TRUE);
9225             oldVariant = gameInfo.variant;
9226             if (appData.debugMode)
9227               fprintf(debugFP, "New variant %d\n", (int) oldVariant);
9228         }
9229
9230
9231         if (gameInfo.fen != NULL) {
9232           Board initial_position;
9233           startedFromSetupPosition = TRUE;
9234           if (!ParseFEN(initial_position, &blackPlaysFirst, gameInfo.fen)) {
9235             Reset(TRUE, TRUE);
9236             DisplayError(_("Bad FEN position in file"), 0);
9237             return FALSE;
9238           }
9239           CopyBoard(boards[0], initial_position);
9240           if (blackPlaysFirst) {
9241             currentMove = forwardMostMove = backwardMostMove = 1;
9242             CopyBoard(boards[1], initial_position);
9243             strcpy(moveList[0], "");
9244             strcpy(parseList[0], "");
9245             timeRemaining[0][1] = whiteTimeRemaining;
9246             timeRemaining[1][1] = blackTimeRemaining;
9247             if (commentList[0] != NULL) {
9248               commentList[1] = commentList[0];
9249               commentList[0] = NULL;
9250             }
9251           } else {
9252             currentMove = forwardMostMove = backwardMostMove = 0;
9253           }
9254           /* [HGM] copy FEN attributes as well. Bugfix 4.3.14m and 4.3.15e: moved to after 'blackPlaysFirst' */
9255           {   int i;
9256               initialRulePlies = FENrulePlies;
9257               epStatus[forwardMostMove] = FENepStatus;
9258               for( i=0; i< nrCastlingRights; i++ )
9259                   initialRights[i] = castlingRights[forwardMostMove][i] = FENcastlingRights[i];
9260           }
9261           yyboardindex = forwardMostMove;
9262           free(gameInfo.fen);
9263           gameInfo.fen = NULL;
9264         }
9265
9266         yyboardindex = forwardMostMove;
9267         cm = (ChessMove) yylex();
9268
9269         /* Handle comments interspersed among the tags */
9270         while (cm == Comment) {
9271             char *p;
9272             if (appData.debugMode)
9273               fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
9274             p = yy_text;
9275             if (*p == '{' || *p == '[' || *p == '(') {
9276                 p[strlen(p) - 1] = NULLCHAR;
9277                 p++;
9278             }
9279             while (*p == '\n') p++;
9280             AppendComment(currentMove, p);
9281             yyboardindex = forwardMostMove;
9282             cm = (ChessMove) yylex();
9283         }
9284     }
9285
9286     /* don't rely on existence of Event tag since if game was
9287      * pasted from clipboard the Event tag may not exist
9288      */
9289     if (numPGNTags > 0){
9290         char *tags;
9291         if (gameInfo.variant == VariantNormal) {
9292           gameInfo.variant = StringToVariant(gameInfo.event);
9293         }
9294         if (!matchMode) {
9295           if( appData.autoDisplayTags ) {
9296             tags = PGNTags(&gameInfo);
9297             TagsPopUp(tags, CmailMsg());
9298             free(tags);
9299           }
9300         }
9301     } else {
9302         /* Make something up, but don't display it now */
9303         SetGameInfo();
9304         TagsPopDown();
9305     }
9306
9307     if (cm == PositionDiagram) {
9308         int i, j;
9309         char *p;
9310         Board initial_position;
9311
9312         if (appData.debugMode)
9313           fprintf(debugFP, "Parsed PositionDiagram: %s\n", yy_text);
9314
9315         if (!startedFromSetupPosition) {
9316             p = yy_text;
9317             for (i = BOARD_HEIGHT - 1; i >= 0; i--)
9318               for (j = BOARD_LEFT; j < BOARD_RGHT; p++)
9319                 switch (*p) {
9320                   case '[':
9321                   case '-':
9322                   case ' ':
9323                   case '\t':
9324                   case '\n':
9325                   case '\r':
9326                     break;
9327                   default:
9328                     initial_position[i][j++] = CharToPiece(*p);
9329                     break;
9330                 }
9331             while (*p == ' ' || *p == '\t' ||
9332                    *p == '\n' || *p == '\r') p++;
9333
9334             if (strncmp(p, "black", strlen("black"))==0)
9335               blackPlaysFirst = TRUE;
9336             else
9337               blackPlaysFirst = FALSE;
9338             startedFromSetupPosition = TRUE;
9339
9340             CopyBoard(boards[0], initial_position);
9341             if (blackPlaysFirst) {
9342                 currentMove = forwardMostMove = backwardMostMove = 1;
9343                 CopyBoard(boards[1], initial_position);
9344                 strcpy(moveList[0], "");
9345                 strcpy(parseList[0], "");
9346                 timeRemaining[0][1] = whiteTimeRemaining;
9347                 timeRemaining[1][1] = blackTimeRemaining;
9348                 if (commentList[0] != NULL) {
9349                     commentList[1] = commentList[0];
9350                     commentList[0] = NULL;
9351                 }
9352             } else {
9353                 currentMove = forwardMostMove = backwardMostMove = 0;
9354             }
9355         }
9356         yyboardindex = forwardMostMove;
9357         cm = (ChessMove) yylex();
9358     }
9359
9360     if (first.pr == NoProc) {
9361         StartChessProgram(&first);
9362     }
9363     InitChessProgram(&first, FALSE);
9364     SendToProgram("force\n", &first);
9365     if (startedFromSetupPosition) {
9366         SendBoard(&first, forwardMostMove);
9367     if (appData.debugMode) {
9368         fprintf(debugFP, "Load Game\n");
9369     }
9370         DisplayBothClocks();
9371     }
9372
9373     /* [HGM] server: flag to write setup moves in broadcast file as one */
9374     loadFlag = appData.suppressLoadMoves;
9375
9376     while (cm == Comment) {
9377         char *p;
9378         if (appData.debugMode)
9379           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
9380         p = yy_text;
9381         if (*p == '{' || *p == '[' || *p == '(') {
9382             p[strlen(p) - 1] = NULLCHAR;
9383             p++;
9384         }
9385         while (*p == '\n') p++;
9386         AppendComment(currentMove, p);
9387         yyboardindex = forwardMostMove;
9388         cm = (ChessMove) yylex();
9389     }
9390
9391     if ((cm == (ChessMove) 0 && lastLoadGameStart != (ChessMove) 0) ||
9392         cm == WhiteWins || cm == BlackWins ||
9393         cm == GameIsDrawn || cm == GameUnfinished) {
9394         DisplayMessage("", _("No moves in game"));
9395         if (cmailMsgLoaded) {
9396             if (appData.debugMode)
9397               fprintf(debugFP, "Setting flipView to %d.\n", FALSE);
9398             ClearHighlights();
9399             flipView = FALSE;
9400         }
9401         DrawPosition(FALSE, boards[currentMove]);
9402         DisplayBothClocks();
9403         gameMode = EditGame;
9404         ModeHighlight();
9405         gameFileFP = NULL;
9406         cmailOldMove = 0;
9407         return TRUE;
9408     }
9409
9410     // [HGM] PV info: routine tests if comment empty
9411     if (!matchMode && (pausing || appData.timeDelay != 0)) {
9412         DisplayComment(currentMove - 1, commentList[currentMove]);
9413     }
9414     if (!matchMode && appData.timeDelay != 0)
9415       DrawPosition(FALSE, boards[currentMove]);
9416
9417     if (gameMode == AnalyzeFile || gameMode == AnalyzeMode) {
9418       programStats.ok_to_send = 1;
9419     }
9420
9421     /* if the first token after the PGN tags is a move
9422      * and not move number 1, retrieve it from the parser
9423      */
9424     if (cm != MoveNumberOne)
9425         LoadGameOneMove(cm);
9426
9427     /* load the remaining moves from the file */
9428     while (LoadGameOneMove((ChessMove)0)) {
9429       timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
9430       timeRemaining[1][forwardMostMove] = blackTimeRemaining;
9431     }
9432
9433     /* rewind to the start of the game */
9434     currentMove = backwardMostMove;
9435
9436     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
9437
9438     if (oldGameMode == AnalyzeFile ||
9439         oldGameMode == AnalyzeMode) {
9440       AnalyzeFileEvent();
9441     }
9442
9443     if (matchMode || appData.timeDelay == 0) {
9444       ToEndEvent();
9445       gameMode = EditGame;
9446       ModeHighlight();
9447     } else if (appData.timeDelay > 0) {
9448       AutoPlayGameLoop();
9449     }
9450
9451     if (appData.debugMode)
9452         fprintf(debugFP, "LoadGame(): on exit, gameMode %d\n", gameMode);
9453
9454     loadFlag = 0; /* [HGM] true game starts */
9455     return TRUE;
9456 }
9457
9458 /* Support for LoadNextPosition, LoadPreviousPosition, ReloadSamePosition */
9459 int
9460 ReloadPosition(offset)
9461      int offset;
9462 {
9463     int positionNumber = lastLoadPositionNumber + offset;
9464     if (lastLoadPositionFP == NULL) {
9465         DisplayError(_("No position has been loaded yet"), 0);
9466         return FALSE;
9467     }
9468     if (positionNumber <= 0) {
9469         DisplayError(_("Can't back up any further"), 0);
9470         return FALSE;
9471     }
9472     return LoadPosition(lastLoadPositionFP, positionNumber,
9473                         lastLoadPositionTitle);
9474 }
9475
9476 /* Load the nth position from the given file */
9477 int
9478 LoadPositionFromFile(filename, n, title)
9479      char *filename;
9480      int n;
9481      char *title;
9482 {
9483     FILE *f;
9484     char buf[MSG_SIZ];
9485
9486     if (strcmp(filename, "-") == 0) {
9487         return LoadPosition(stdin, n, "stdin");
9488     } else {
9489         f = fopen(filename, "rb");
9490         if (f == NULL) {
9491             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
9492             DisplayError(buf, errno);
9493             return FALSE;
9494         } else {
9495             return LoadPosition(f, n, title);
9496         }
9497     }
9498 }
9499
9500 /* Load the nth position from the given open file, and close it */
9501 int
9502 LoadPosition(f, positionNumber, title)
9503      FILE *f;
9504      int positionNumber;
9505      char *title;
9506 {
9507     char *p, line[MSG_SIZ];
9508     Board initial_position;
9509     int i, j, fenMode, pn;
9510
9511     if (gameMode == Training )
9512         SetTrainingModeOff();
9513
9514     if (gameMode != BeginningOfGame) {
9515         Reset(FALSE, TRUE);
9516     }
9517     if (lastLoadPositionFP != NULL && lastLoadPositionFP != f) {
9518         fclose(lastLoadPositionFP);
9519     }
9520     if (positionNumber == 0) positionNumber = 1;
9521     lastLoadPositionFP = f;
9522     lastLoadPositionNumber = positionNumber;
9523     strcpy(lastLoadPositionTitle, title);
9524     if (first.pr == NoProc) {
9525       StartChessProgram(&first);
9526       InitChessProgram(&first, FALSE);
9527     }
9528     pn = positionNumber;
9529     if (positionNumber < 0) {
9530         /* Negative position number means to seek to that byte offset */
9531         if (fseek(f, -positionNumber, 0) == -1) {
9532             DisplayError(_("Can't seek on position file"), 0);
9533             return FALSE;
9534         };
9535         pn = 1;
9536     } else {
9537         if (fseek(f, 0, 0) == -1) {
9538             if (f == lastLoadPositionFP ?
9539                 positionNumber == lastLoadPositionNumber + 1 :
9540                 positionNumber == 1) {
9541                 pn = 1;
9542             } else {
9543                 DisplayError(_("Can't seek on position file"), 0);
9544                 return FALSE;
9545             }
9546         }
9547     }
9548     /* See if this file is FEN or old-style xboard */
9549     if (fgets(line, MSG_SIZ, f) == NULL) {
9550         DisplayError(_("Position not found in file"), 0);
9551         return FALSE;
9552     }
9553     // [HGM] FEN can begin with digit, any piece letter valid in this variant, or a + for Shogi promoted pieces
9554     fenMode = line[0] >= '0' && line[0] <= '9' || line[0] == '+' || CharToPiece(line[0]) != EmptySquare;
9555
9556     if (pn >= 2) {
9557         if (fenMode || line[0] == '#') pn--;
9558         while (pn > 0) {
9559             /* skip positions before number pn */
9560             if (fgets(line, MSG_SIZ, f) == NULL) {
9561                 Reset(TRUE, TRUE);
9562                 DisplayError(_("Position not found in file"), 0);
9563                 return FALSE;
9564             }
9565             if (fenMode || line[0] == '#') pn--;
9566         }
9567     }
9568
9569     if (fenMode) {
9570         if (!ParseFEN(initial_position, &blackPlaysFirst, line)) {
9571             DisplayError(_("Bad FEN position in file"), 0);
9572             return FALSE;
9573         }
9574     } else {
9575         (void) fgets(line, MSG_SIZ, f);
9576         (void) fgets(line, MSG_SIZ, f);
9577
9578         for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
9579             (void) fgets(line, MSG_SIZ, f);
9580             for (p = line, j = BOARD_LEFT; j < BOARD_RGHT; p++) {
9581                 if (*p == ' ')
9582                   continue;
9583                 initial_position[i][j++] = CharToPiece(*p);
9584             }
9585         }
9586
9587         blackPlaysFirst = FALSE;
9588         if (!feof(f)) {
9589             (void) fgets(line, MSG_SIZ, f);
9590             if (strncmp(line, "black", strlen("black"))==0)
9591               blackPlaysFirst = TRUE;
9592         }
9593     }
9594     startedFromSetupPosition = TRUE;
9595
9596     SendToProgram("force\n", &first);
9597     CopyBoard(boards[0], initial_position);
9598     if (blackPlaysFirst) {
9599         currentMove = forwardMostMove = backwardMostMove = 1;
9600         strcpy(moveList[0], "");
9601         strcpy(parseList[0], "");
9602         CopyBoard(boards[1], initial_position);
9603         DisplayMessage("", _("Black to play"));
9604     } else {
9605         currentMove = forwardMostMove = backwardMostMove = 0;
9606         DisplayMessage("", _("White to play"));
9607     }
9608           /* [HGM] copy FEN attributes as well */
9609           {   int i;
9610               initialRulePlies = FENrulePlies;
9611               epStatus[forwardMostMove] = FENepStatus;
9612               for( i=0; i< nrCastlingRights; i++ )
9613                   castlingRights[forwardMostMove][i] = FENcastlingRights[i];
9614           }
9615     SendBoard(&first, forwardMostMove);
9616     if (appData.debugMode) {
9617 int i, j;
9618   for(i=0;i<2;i++){for(j=0;j<6;j++)fprintf(debugFP, " %d", castlingRights[i][j]);fprintf(debugFP,"\n");}
9619   for(j=0;j<6;j++)fprintf(debugFP, " %d", initialRights[j]);fprintf(debugFP,"\n");
9620         fprintf(debugFP, "Load Position\n");
9621     }
9622
9623     if (positionNumber > 1) {
9624         sprintf(line, "%s %d", title, positionNumber);
9625         DisplayTitle(line);
9626     } else {
9627         DisplayTitle(title);
9628     }
9629     gameMode = EditGame;
9630     ModeHighlight();
9631     ResetClocks();
9632     timeRemaining[0][1] = whiteTimeRemaining;
9633     timeRemaining[1][1] = blackTimeRemaining;
9634     DrawPosition(FALSE, boards[currentMove]);
9635
9636     return TRUE;
9637 }
9638
9639
9640 void
9641 CopyPlayerNameIntoFileName(dest, src)
9642      char **dest, *src;
9643 {
9644     while (*src != NULLCHAR && *src != ',') {
9645         if (*src == ' ') {
9646             *(*dest)++ = '_';
9647             src++;
9648         } else {
9649             *(*dest)++ = *src++;
9650         }
9651     }
9652 }
9653
9654 char *DefaultFileName(ext)
9655      char *ext;
9656 {
9657     static char def[MSG_SIZ];
9658     char *p;
9659
9660     if (gameInfo.white != NULL && gameInfo.white[0] != '-') {
9661         p = def;
9662         CopyPlayerNameIntoFileName(&p, gameInfo.white);
9663         *p++ = '-';
9664         CopyPlayerNameIntoFileName(&p, gameInfo.black);
9665         *p++ = '.';
9666         strcpy(p, ext);
9667     } else {
9668         def[0] = NULLCHAR;
9669     }
9670     return def;
9671 }
9672
9673 /* Save the current game to the given file */
9674 int
9675 SaveGameToFile(filename, append)
9676      char *filename;
9677      int append;
9678 {
9679     FILE *f;
9680     char buf[MSG_SIZ];
9681
9682     if (strcmp(filename, "-") == 0) {
9683         return SaveGame(stdout, 0, NULL);
9684     } else {
9685         f = fopen(filename, append ? "a" : "w");
9686         if (f == NULL) {
9687             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
9688             DisplayError(buf, errno);
9689             return FALSE;
9690         } else {
9691             return SaveGame(f, 0, NULL);
9692         }
9693     }
9694 }
9695
9696 char *
9697 SavePart(str)
9698      char *str;
9699 {
9700     static char buf[MSG_SIZ];
9701     char *p;
9702
9703     p = strchr(str, ' ');
9704     if (p == NULL) return str;
9705     strncpy(buf, str, p - str);
9706     buf[p - str] = NULLCHAR;
9707     return buf;
9708 }
9709
9710 #define PGN_MAX_LINE 75
9711
9712 #define PGN_SIDE_WHITE  0
9713 #define PGN_SIDE_BLACK  1
9714
9715 /* [AS] */
9716 static int FindFirstMoveOutOfBook( int side )
9717 {
9718     int result = -1;
9719
9720     if( backwardMostMove == 0 && ! startedFromSetupPosition) {
9721         int index = backwardMostMove;
9722         int has_book_hit = 0;
9723
9724         if( (index % 2) != side ) {
9725             index++;
9726         }
9727
9728         while( index < forwardMostMove ) {
9729             /* Check to see if engine is in book */
9730             int depth = pvInfoList[index].depth;
9731             int score = pvInfoList[index].score;
9732             int in_book = 0;
9733
9734             if( depth <= 2 ) {
9735                 in_book = 1;
9736             }
9737             else if( score == 0 && depth == 63 ) {
9738                 in_book = 1; /* Zappa */
9739             }
9740             else if( score == 2 && depth == 99 ) {
9741                 in_book = 1; /* Abrok */
9742             }
9743
9744             has_book_hit += in_book;
9745
9746             if( ! in_book ) {
9747                 result = index;
9748
9749                 break;
9750             }
9751
9752             index += 2;
9753         }
9754     }
9755
9756     return result;
9757 }
9758
9759 /* [AS] */
9760 void GetOutOfBookInfo( char * buf )
9761 {
9762     int oob[2];
9763     int i;
9764     int offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
9765
9766     oob[0] = FindFirstMoveOutOfBook( PGN_SIDE_WHITE );
9767     oob[1] = FindFirstMoveOutOfBook( PGN_SIDE_BLACK );
9768
9769     *buf = '\0';
9770
9771     if( oob[0] >= 0 || oob[1] >= 0 ) {
9772         for( i=0; i<2; i++ ) {
9773             int idx = oob[i];
9774
9775             if( idx >= 0 ) {
9776                 if( i > 0 && oob[0] >= 0 ) {
9777                     strcat( buf, "   " );
9778                 }
9779
9780                 sprintf( buf+strlen(buf), "%d%s. ", (idx - offset)/2 + 1, idx & 1 ? ".." : "" );
9781                 sprintf( buf+strlen(buf), "%s%.2f",
9782                     pvInfoList[idx].score >= 0 ? "+" : "",
9783                     pvInfoList[idx].score / 100.0 );
9784             }
9785         }
9786     }
9787 }
9788
9789 /* Save game in PGN style and close the file */
9790 int
9791 SaveGamePGN(f)
9792      FILE *f;
9793 {
9794     int i, offset, linelen, newblock;
9795     time_t tm;
9796 //    char *movetext;
9797     char numtext[32];
9798     int movelen, numlen, blank;
9799     char move_buffer[100]; /* [AS] Buffer for move+PV info */
9800
9801     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
9802
9803     tm = time((time_t *) NULL);
9804
9805     PrintPGNTags(f, &gameInfo);
9806
9807     if (backwardMostMove > 0 || startedFromSetupPosition) {
9808         char *fen = PositionToFEN(backwardMostMove, NULL);
9809         fprintf(f, "[FEN \"%s\"]\n[SetUp \"1\"]\n", fen);
9810         fprintf(f, "\n{--------------\n");
9811         PrintPosition(f, backwardMostMove);
9812         fprintf(f, "--------------}\n");
9813         free(fen);
9814     }
9815     else {
9816         /* [AS] Out of book annotation */
9817         if( appData.saveOutOfBookInfo ) {
9818             char buf[64];
9819
9820             GetOutOfBookInfo( buf );
9821
9822             if( buf[0] != '\0' ) {
9823                 fprintf( f, "[%s \"%s\"]\n", PGN_OUT_OF_BOOK, buf );
9824             }
9825         }
9826
9827         fprintf(f, "\n");
9828     }
9829
9830     i = backwardMostMove;
9831     linelen = 0;
9832     newblock = TRUE;
9833
9834     while (i < forwardMostMove) {
9835         /* Print comments preceding this move */
9836         if (commentList[i] != NULL) {
9837             if (linelen > 0) fprintf(f, "\n");
9838             fprintf(f, "{\n%s}\n", commentList[i]);
9839             linelen = 0;
9840             newblock = TRUE;
9841         }
9842
9843         /* Format move number */
9844         if ((i % 2) == 0) {
9845             sprintf(numtext, "%d.", (i - offset)/2 + 1);
9846         } else {
9847             if (newblock) {
9848                 sprintf(numtext, "%d...", (i - offset)/2 + 1);
9849             } else {
9850                 numtext[0] = NULLCHAR;
9851             }
9852         }
9853         numlen = strlen(numtext);
9854         newblock = FALSE;
9855
9856         /* Print move number */
9857         blank = linelen > 0 && numlen > 0;
9858         if (linelen + (blank ? 1 : 0) + numlen > PGN_MAX_LINE) {
9859             fprintf(f, "\n");
9860             linelen = 0;
9861             blank = 0;
9862         }
9863         if (blank) {
9864             fprintf(f, " ");
9865             linelen++;
9866         }
9867         fprintf(f, "%s", numtext);
9868         linelen += numlen;
9869
9870         /* Get move */
9871         strcpy(move_buffer, SavePart(parseList[i])); // [HGM] pgn: print move via buffer, so it can be edited
9872         movelen = strlen(move_buffer); /* [HGM] pgn: line-break point before move */
9873
9874         /* Print move */
9875         blank = linelen > 0 && movelen > 0;
9876         if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
9877             fprintf(f, "\n");
9878             linelen = 0;
9879             blank = 0;
9880         }
9881         if (blank) {
9882             fprintf(f, " ");
9883             linelen++;
9884         }
9885         fprintf(f, "%s", move_buffer);
9886         linelen += movelen;
9887
9888         /* [AS] Add PV info if present */
9889         if( i >= 0 && appData.saveExtendedInfoInPGN && pvInfoList[i].depth > 0 ) {
9890             /* [HGM] add time */
9891             char buf[MSG_SIZ]; int seconds = 0;
9892
9893             if(i >= backwardMostMove) {
9894                 if(WhiteOnMove(i))
9895                         seconds = timeRemaining[0][i] - timeRemaining[0][i+1]
9896                                   + GetTimeQuota(i/2) / (1000*WhitePlayer()->timeOdds);
9897                 else
9898                         seconds = timeRemaining[1][i] - timeRemaining[1][i+1]
9899                                   + GetTimeQuota(i/2) / (1000*WhitePlayer()->other->timeOdds);
9900             }
9901             seconds = (seconds+50)/100; // deci-seconds, rounded to nearest
9902
9903             if( seconds <= 0) buf[0] = 0; else
9904             if( seconds < 30 ) sprintf(buf, " %3.1f%c", seconds/10., 0); else {
9905                 seconds = (seconds + 4)/10; // round to full seconds
9906                 if( seconds < 60 ) sprintf(buf, " %d%c", seconds, 0); else
9907                                    sprintf(buf, " %d:%02d%c", seconds/60, seconds%60, 0);
9908             }
9909
9910             sprintf( move_buffer, "{%s%.2f/%d%s}",
9911                 pvInfoList[i].score >= 0 ? "+" : "",
9912                 pvInfoList[i].score / 100.0,
9913                 pvInfoList[i].depth,
9914                 buf );
9915
9916             movelen = strlen(move_buffer); /* [HGM] pgn: line-break point after move */
9917
9918             /* Print score/depth */
9919             blank = linelen > 0 && movelen > 0;
9920             if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
9921                 fprintf(f, "\n");
9922                 linelen = 0;
9923                 blank = 0;
9924             }
9925             if (blank) {
9926                 fprintf(f, " ");
9927                 linelen++;
9928             }
9929             fprintf(f, "%s", move_buffer);
9930             linelen += movelen;
9931         }
9932
9933         i++;
9934     }
9935
9936     /* Start a new line */
9937     if (linelen > 0) fprintf(f, "\n");
9938
9939     /* Print comments after last move */
9940     if (commentList[i] != NULL) {
9941         fprintf(f, "{\n%s}\n", commentList[i]);
9942     }
9943
9944     /* Print result */
9945     if (gameInfo.resultDetails != NULL &&
9946         gameInfo.resultDetails[0] != NULLCHAR) {
9947         fprintf(f, "{%s} %s\n\n", gameInfo.resultDetails,
9948                 PGNResult(gameInfo.result));
9949     } else {
9950         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
9951     }
9952
9953     fclose(f);
9954     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
9955     return TRUE;
9956 }
9957
9958 /* Save game in old style and close the file */
9959 int
9960 SaveGameOldStyle(f)
9961      FILE *f;
9962 {
9963     int i, offset;
9964     time_t tm;
9965
9966     tm = time((time_t *) NULL);
9967
9968     fprintf(f, "# %s game file -- %s", programName, ctime(&tm));
9969     PrintOpponents(f);
9970
9971     if (backwardMostMove > 0 || startedFromSetupPosition) {
9972         fprintf(f, "\n[--------------\n");
9973         PrintPosition(f, backwardMostMove);
9974         fprintf(f, "--------------]\n");
9975     } else {
9976         fprintf(f, "\n");
9977     }
9978
9979     i = backwardMostMove;
9980     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
9981
9982     while (i < forwardMostMove) {
9983         if (commentList[i] != NULL) {
9984             fprintf(f, "[%s]\n", commentList[i]);
9985         }
9986
9987         if ((i % 2) == 1) {
9988             fprintf(f, "%d. ...  %s\n", (i - offset)/2 + 1, parseList[i]);
9989             i++;
9990         } else {
9991             fprintf(f, "%d. %s  ", (i - offset)/2 + 1, parseList[i]);
9992             i++;
9993             if (commentList[i] != NULL) {
9994                 fprintf(f, "\n");
9995                 continue;
9996             }
9997             if (i >= forwardMostMove) {
9998                 fprintf(f, "\n");
9999                 break;
10000             }
10001             fprintf(f, "%s\n", parseList[i]);
10002             i++;
10003         }
10004     }
10005
10006     if (commentList[i] != NULL) {
10007         fprintf(f, "[%s]\n", commentList[i]);
10008     }
10009
10010     /* This isn't really the old style, but it's close enough */
10011     if (gameInfo.resultDetails != NULL &&
10012         gameInfo.resultDetails[0] != NULLCHAR) {
10013         fprintf(f, "%s (%s)\n\n", PGNResult(gameInfo.result),
10014                 gameInfo.resultDetails);
10015     } else {
10016         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
10017     }
10018
10019     fclose(f);
10020     return TRUE;
10021 }
10022
10023 /* Save the current game to open file f and close the file */
10024 int
10025 SaveGame(f, dummy, dummy2)
10026      FILE *f;
10027      int dummy;
10028      char *dummy2;
10029 {
10030     if (gameMode == EditPosition) EditPositionDone();
10031     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
10032     if (appData.oldSaveStyle)
10033       return SaveGameOldStyle(f);
10034     else
10035       return SaveGamePGN(f);
10036 }
10037
10038 /* Save the current position to the given file */
10039 int
10040 SavePositionToFile(filename)
10041      char *filename;
10042 {
10043     FILE *f;
10044     char buf[MSG_SIZ];
10045
10046     if (strcmp(filename, "-") == 0) {
10047         return SavePosition(stdout, 0, NULL);
10048     } else {
10049         f = fopen(filename, "a");
10050         if (f == NULL) {
10051             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
10052             DisplayError(buf, errno);
10053             return FALSE;
10054         } else {
10055             SavePosition(f, 0, NULL);
10056             return TRUE;
10057         }
10058     }
10059 }
10060
10061 /* Save the current position to the given open file and close the file */
10062 int
10063 SavePosition(f, dummy, dummy2)
10064      FILE *f;
10065      int dummy;
10066      char *dummy2;
10067 {
10068     time_t tm;
10069     char *fen;
10070
10071     if (appData.oldSaveStyle) {
10072         tm = time((time_t *) NULL);
10073
10074         fprintf(f, "# %s position file -- %s", programName, ctime(&tm));
10075         PrintOpponents(f);
10076         fprintf(f, "[--------------\n");
10077         PrintPosition(f, currentMove);
10078         fprintf(f, "--------------]\n");
10079     } else {
10080         fen = PositionToFEN(currentMove, NULL);
10081         fprintf(f, "%s\n", fen);
10082         free(fen);
10083     }
10084     fclose(f);
10085     return TRUE;
10086 }
10087
10088 void
10089 ReloadCmailMsgEvent(unregister)
10090      int unregister;
10091 {
10092 #if !WIN32
10093     static char *inFilename = NULL;
10094     static char *outFilename;
10095     int i;
10096     struct stat inbuf, outbuf;
10097     int status;
10098
10099     /* Any registered moves are unregistered if unregister is set, */
10100     /* i.e. invoked by the signal handler */
10101     if (unregister) {
10102         for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
10103             cmailMoveRegistered[i] = FALSE;
10104             if (cmailCommentList[i] != NULL) {
10105                 free(cmailCommentList[i]);
10106                 cmailCommentList[i] = NULL;
10107             }
10108         }
10109         nCmailMovesRegistered = 0;
10110     }
10111
10112     for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
10113         cmailResult[i] = CMAIL_NOT_RESULT;
10114     }
10115     nCmailResults = 0;
10116
10117     if (inFilename == NULL) {
10118         /* Because the filenames are static they only get malloced once  */
10119         /* and they never get freed                                      */
10120         inFilename = (char *) malloc(strlen(appData.cmailGameName) + 9);
10121         sprintf(inFilename, "%s.game.in", appData.cmailGameName);
10122
10123         outFilename = (char *) malloc(strlen(appData.cmailGameName) + 5);
10124         sprintf(outFilename, "%s.out", appData.cmailGameName);
10125     }
10126
10127     status = stat(outFilename, &outbuf);
10128     if (status < 0) {
10129         cmailMailedMove = FALSE;
10130     } else {
10131         status = stat(inFilename, &inbuf);
10132         cmailMailedMove = (inbuf.st_mtime < outbuf.st_mtime);
10133     }
10134
10135     /* LoadGameFromFile(CMAIL_MAX_GAMES) with cmailMsgLoaded == TRUE
10136        counts the games, notes how each one terminated, etc.
10137
10138        It would be nice to remove this kludge and instead gather all
10139        the information while building the game list.  (And to keep it
10140        in the game list nodes instead of having a bunch of fixed-size
10141        parallel arrays.)  Note this will require getting each game's
10142        termination from the PGN tags, as the game list builder does
10143        not process the game moves.  --mann
10144        */
10145     cmailMsgLoaded = TRUE;
10146     LoadGameFromFile(inFilename, CMAIL_MAX_GAMES, "", FALSE);
10147
10148     /* Load first game in the file or popup game menu */
10149     LoadGameFromFile(inFilename, 0, appData.cmailGameName, TRUE);
10150
10151 #endif /* !WIN32 */
10152     return;
10153 }
10154
10155 int
10156 RegisterMove()
10157 {
10158     FILE *f;
10159     char string[MSG_SIZ];
10160
10161     if (   cmailMailedMove
10162         || (cmailResult[lastLoadGameNumber - 1] == CMAIL_OLD_RESULT)) {
10163         return TRUE;            /* Allow free viewing  */
10164     }
10165
10166     /* Unregister move to ensure that we don't leave RegisterMove        */
10167     /* with the move registered when the conditions for registering no   */
10168     /* longer hold                                                       */
10169     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
10170         cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
10171         nCmailMovesRegistered --;
10172
10173         if (cmailCommentList[lastLoadGameNumber - 1] != NULL)
10174           {
10175               free(cmailCommentList[lastLoadGameNumber - 1]);
10176               cmailCommentList[lastLoadGameNumber - 1] = NULL;
10177           }
10178     }
10179
10180     if (cmailOldMove == -1) {
10181         DisplayError(_("You have edited the game history.\nUse Reload Same Game and make your move again."), 0);
10182         return FALSE;
10183     }
10184
10185     if (currentMove > cmailOldMove + 1) {
10186         DisplayError(_("You have entered too many moves.\nBack up to the correct position and try again."), 0);
10187         return FALSE;
10188     }
10189
10190     if (currentMove < cmailOldMove) {
10191         DisplayError(_("Displayed position is not current.\nStep forward to the correct position and try again."), 0);
10192         return FALSE;
10193     }
10194
10195     if (forwardMostMove > currentMove) {
10196         /* Silently truncate extra moves */
10197         TruncateGame();
10198     }
10199
10200     if (   (currentMove == cmailOldMove + 1)
10201         || (   (currentMove == cmailOldMove)
10202             && (   (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_ACCEPT)
10203                 || (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_RESIGN)))) {
10204         if (gameInfo.result != GameUnfinished) {
10205             cmailResult[lastLoadGameNumber - 1] = CMAIL_NEW_RESULT;
10206         }
10207
10208         if (commentList[currentMove] != NULL) {
10209             cmailCommentList[lastLoadGameNumber - 1]
10210               = StrSave(commentList[currentMove]);
10211         }
10212         strcpy(cmailMove[lastLoadGameNumber - 1], moveList[currentMove - 1]);
10213
10214         if (appData.debugMode)
10215           fprintf(debugFP, "Saving %s for game %d\n",
10216                   cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
10217
10218         sprintf(string,
10219                 "%s.game.out.%d", appData.cmailGameName, lastLoadGameNumber);
10220
10221         f = fopen(string, "w");
10222         if (appData.oldSaveStyle) {
10223             SaveGameOldStyle(f); /* also closes the file */
10224
10225             sprintf(string, "%s.pos.out", appData.cmailGameName);
10226             f = fopen(string, "w");
10227             SavePosition(f, 0, NULL); /* also closes the file */
10228         } else {
10229             fprintf(f, "{--------------\n");
10230             PrintPosition(f, currentMove);
10231             fprintf(f, "--------------}\n\n");
10232
10233             SaveGame(f, 0, NULL); /* also closes the file*/
10234         }
10235
10236         cmailMoveRegistered[lastLoadGameNumber - 1] = TRUE;
10237         nCmailMovesRegistered ++;
10238     } else if (nCmailGames == 1) {
10239         DisplayError(_("You have not made a move yet"), 0);
10240         return FALSE;
10241     }
10242
10243     return TRUE;
10244 }
10245
10246 void
10247 MailMoveEvent()
10248 {
10249 #if !WIN32
10250     static char *partCommandString = "cmail -xv%s -remail -game %s 2>&1";
10251     FILE *commandOutput;
10252     char buffer[MSG_SIZ], msg[MSG_SIZ], string[MSG_SIZ];
10253     int nBytes = 0;             /*  Suppress warnings on uninitialized variables    */
10254     int nBuffers;
10255     int i;
10256     int archived;
10257     char *arcDir;
10258
10259     if (! cmailMsgLoaded) {
10260         DisplayError(_("The cmail message is not loaded.\nUse Reload CMail Message and make your move again."), 0);
10261         return;
10262     }
10263
10264     if (nCmailGames == nCmailResults) {
10265         DisplayError(_("No unfinished games"), 0);
10266         return;
10267     }
10268
10269 #if CMAIL_PROHIBIT_REMAIL
10270     if (cmailMailedMove) {
10271         sprintf(msg, _("You have already mailed a move.\nWait until a move arrives from your opponent.\nTo resend the same move, type\n\"cmail -remail -game %s\"\non the command line."), appData.cmailGameName);
10272         DisplayError(msg, 0);
10273         return;
10274     }
10275 #endif
10276
10277     if (! (cmailMailedMove || RegisterMove())) return;
10278
10279     if (   cmailMailedMove
10280         || (nCmailMovesRegistered + nCmailResults == nCmailGames)) {
10281         sprintf(string, partCommandString,
10282                 appData.debugMode ? " -v" : "", appData.cmailGameName);
10283         commandOutput = popen(string, "r");
10284
10285         if (commandOutput == NULL) {
10286             DisplayError(_("Failed to invoke cmail"), 0);
10287         } else {
10288             for (nBuffers = 0; (! feof(commandOutput)); nBuffers ++) {
10289                 nBytes = fread(buffer, 1, MSG_SIZ - 1, commandOutput);
10290             }
10291             if (nBuffers > 1) {
10292                 (void) memcpy(msg, buffer + nBytes, MSG_SIZ - nBytes - 1);
10293                 (void) memcpy(msg + MSG_SIZ - nBytes - 1, buffer, nBytes);
10294                 nBytes = MSG_SIZ - 1;
10295             } else {
10296                 (void) memcpy(msg, buffer, nBytes);
10297             }
10298             *(msg + nBytes) = '\0'; /* \0 for end-of-string*/
10299
10300             if(StrStr(msg, "Mailed cmail message to ") != NULL) {
10301                 cmailMailedMove = TRUE; /* Prevent >1 moves    */
10302
10303                 archived = TRUE;
10304                 for (i = 0; i < nCmailGames; i ++) {
10305                     if (cmailResult[i] == CMAIL_NOT_RESULT) {
10306                         archived = FALSE;
10307                     }
10308                 }
10309                 if (   archived
10310                     && (   (arcDir = (char *) getenv("CMAIL_ARCDIR"))
10311                         != NULL)) {
10312                     sprintf(buffer, "%s/%s.%s.archive",
10313                             arcDir,
10314                             appData.cmailGameName,
10315                             gameInfo.date);
10316                     LoadGameFromFile(buffer, 1, buffer, FALSE);
10317                     cmailMsgLoaded = FALSE;
10318                 }
10319             }
10320
10321             DisplayInformation(msg);
10322             pclose(commandOutput);
10323         }
10324     } else {
10325         if ((*cmailMsg) != '\0') {
10326             DisplayInformation(cmailMsg);
10327         }
10328     }
10329
10330     return;
10331 #endif /* !WIN32 */
10332 }
10333
10334 char *
10335 CmailMsg()
10336 {
10337 #if WIN32
10338     return NULL;
10339 #else
10340     int  prependComma = 0;
10341     char number[5];
10342     char string[MSG_SIZ];       /* Space for game-list */
10343     int  i;
10344
10345     if (!cmailMsgLoaded) return "";
10346
10347     if (cmailMailedMove) {
10348         sprintf(cmailMsg, _("Waiting for reply from opponent\n"));
10349     } else {
10350         /* Create a list of games left */
10351         sprintf(string, "[");
10352         for (i = 0; i < nCmailGames; i ++) {
10353             if (! (   cmailMoveRegistered[i]
10354                    || (cmailResult[i] == CMAIL_OLD_RESULT))) {
10355                 if (prependComma) {
10356                     sprintf(number, ",%d", i + 1);
10357                 } else {
10358                     sprintf(number, "%d", i + 1);
10359                     prependComma = 1;
10360                 }
10361
10362                 strcat(string, number);
10363             }
10364         }
10365         strcat(string, "]");
10366
10367         if (nCmailMovesRegistered + nCmailResults == 0) {
10368             switch (nCmailGames) {
10369               case 1:
10370                 sprintf(cmailMsg,
10371                         _("Still need to make move for game\n"));
10372                 break;
10373
10374               case 2:
10375                 sprintf(cmailMsg,
10376                         _("Still need to make moves for both games\n"));
10377                 break;
10378
10379               default:
10380                 sprintf(cmailMsg,
10381                         _("Still need to make moves for all %d games\n"),
10382                         nCmailGames);
10383                 break;
10384             }
10385         } else {
10386             switch (nCmailGames - nCmailMovesRegistered - nCmailResults) {
10387               case 1:
10388                 sprintf(cmailMsg,
10389                         _("Still need to make a move for game %s\n"),
10390                         string);
10391                 break;
10392
10393               case 0:
10394                 if (nCmailResults == nCmailGames) {
10395                     sprintf(cmailMsg, _("No unfinished games\n"));
10396                 } else {
10397                     sprintf(cmailMsg, _("Ready to send mail\n"));
10398                 }
10399                 break;
10400
10401               default:
10402                 sprintf(cmailMsg,
10403                         _("Still need to make moves for games %s\n"),
10404                         string);
10405             }
10406         }
10407     }
10408     return cmailMsg;
10409 #endif /* WIN32 */
10410 }
10411
10412 void
10413 ResetGameEvent()
10414 {
10415     if (gameMode == Training)
10416       SetTrainingModeOff();
10417
10418     Reset(TRUE, TRUE);
10419     cmailMsgLoaded = FALSE;
10420     if (appData.icsActive) {
10421       SendToICS(ics_prefix);
10422       SendToICS("refresh\n");
10423     }
10424 }
10425
10426 void
10427 ExitEvent(status)
10428      int status;
10429 {
10430     exiting++;
10431     if (exiting > 2) {
10432       /* Give up on clean exit */
10433       exit(status);
10434     }
10435     if (exiting > 1) {
10436       /* Keep trying for clean exit */
10437       return;
10438     }
10439
10440     if (appData.icsActive && appData.colorize) Colorize(ColorNone, FALSE);
10441
10442     if (telnetISR != NULL) {
10443       RemoveInputSource(telnetISR);
10444     }
10445     if (icsPR != NoProc) {
10446       DestroyChildProcess(icsPR, TRUE);
10447     }
10448
10449     /* [HGM] crash: leave writing PGN and position entirely to GameEnds() */
10450     GameEnds(gameInfo.result, gameInfo.resultDetails==NULL ? "xboard exit" : gameInfo.resultDetails, GE_PLAYER);
10451
10452     /* [HGM] crash: the above GameEnds() is a dud if another one was running */
10453     /* make sure this other one finishes before killing it!                  */
10454     if(endingGame) { int count = 0;
10455         if(appData.debugMode) fprintf(debugFP, "ExitEvent() during GameEnds(), wait\n");
10456         while(endingGame && count++ < 10) DoSleep(1);
10457         if(appData.debugMode && endingGame) fprintf(debugFP, "GameEnds() seems stuck, proceed exiting\n");
10458     }
10459
10460     /* Kill off chess programs */
10461     if (first.pr != NoProc) {
10462         ExitAnalyzeMode();
10463
10464         DoSleep( appData.delayBeforeQuit );
10465         SendToProgram("quit\n", &first);
10466         DoSleep( appData.delayAfterQuit );
10467         DestroyChildProcess(first.pr, 10 /* [AS] first.useSigterm */ );
10468     }
10469     if (second.pr != NoProc) {
10470         DoSleep( appData.delayBeforeQuit );
10471         SendToProgram("quit\n", &second);
10472         DoSleep( appData.delayAfterQuit );
10473         DestroyChildProcess(second.pr, 10 /* [AS] second.useSigterm */ );
10474     }
10475     if (first.isr != NULL) {
10476         RemoveInputSource(first.isr);
10477     }
10478     if (second.isr != NULL) {
10479         RemoveInputSource(second.isr);
10480     }
10481
10482     ShutDownFrontEnd();
10483     exit(status);
10484 }
10485
10486 void
10487 PauseEvent()
10488 {
10489     if (appData.debugMode)
10490         fprintf(debugFP, "PauseEvent(): pausing %d\n", pausing);
10491     if (pausing) {
10492         pausing = FALSE;
10493         ModeHighlight();
10494         if (gameMode == MachinePlaysWhite ||
10495             gameMode == MachinePlaysBlack) {
10496             StartClocks();
10497         } else {
10498             DisplayBothClocks();
10499         }
10500         if (gameMode == PlayFromGameFile) {
10501             if (appData.timeDelay >= 0)
10502                 AutoPlayGameLoop();
10503         } else if (gameMode == IcsExamining && pauseExamInvalid) {
10504             Reset(FALSE, TRUE);
10505             SendToICS(ics_prefix);
10506             SendToICS("refresh\n");
10507         } else if (currentMove < forwardMostMove) {
10508             ForwardInner(forwardMostMove);
10509         }
10510         pauseExamInvalid = FALSE;
10511     } else {
10512         switch (gameMode) {
10513           default:
10514             return;
10515           case IcsExamining:
10516             pauseExamForwardMostMove = forwardMostMove;
10517             pauseExamInvalid = FALSE;
10518             /* fall through */
10519           case IcsObserving:
10520           case IcsPlayingWhite:
10521           case IcsPlayingBlack:
10522             pausing = TRUE;
10523             ModeHighlight();
10524             return;
10525           case PlayFromGameFile:
10526             (void) StopLoadGameTimer();
10527             pausing = TRUE;
10528             ModeHighlight();
10529             break;
10530           case BeginningOfGame:
10531             if (appData.icsActive) return;
10532             /* else fall through */
10533           case MachinePlaysWhite:
10534           case MachinePlaysBlack:
10535           case TwoMachinesPlay:
10536             if (forwardMostMove == 0)
10537               return;           /* don't pause if no one has moved */
10538             if ((gameMode == MachinePlaysWhite &&
10539                  !WhiteOnMove(forwardMostMove)) ||
10540                 (gameMode == MachinePlaysBlack &&
10541                  WhiteOnMove(forwardMostMove))) {
10542                 StopClocks();
10543             }
10544             pausing = TRUE;
10545             ModeHighlight();
10546             break;
10547         }
10548     }
10549 }
10550
10551 void
10552 EditCommentEvent()
10553 {
10554     char title[MSG_SIZ];
10555
10556     if (currentMove < 1 || parseList[currentMove - 1][0] == NULLCHAR) {
10557         strcpy(title, _("Edit comment"));
10558     } else {
10559         sprintf(title, _("Edit comment on %d.%s%s"), (currentMove - 1) / 2 + 1,
10560                 WhiteOnMove(currentMove - 1) ? " " : ".. ",
10561                 parseList[currentMove - 1]);
10562     }
10563
10564     EditCommentPopUp(currentMove, title, commentList[currentMove]);
10565 }
10566
10567
10568 void
10569 EditTagsEvent()
10570 {
10571     char *tags = PGNTags(&gameInfo);
10572     EditTagsPopUp(tags);
10573     free(tags);
10574 }
10575
10576 void
10577 AnalyzeModeEvent()
10578 {
10579     if (appData.noChessProgram || gameMode == AnalyzeMode)
10580       return;
10581
10582     if (gameMode != AnalyzeFile) {
10583         if (!appData.icsEngineAnalyze) {
10584                EditGameEvent();
10585                if (gameMode != EditGame) return;
10586         }
10587         ResurrectChessProgram();
10588         SendToProgram("analyze\n", &first);
10589         first.analyzing = TRUE;
10590         /*first.maybeThinking = TRUE;*/
10591         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
10592         EngineOutputPopUp();
10593     }
10594     if (!appData.icsEngineAnalyze) gameMode = AnalyzeMode;
10595     pausing = FALSE;
10596     ModeHighlight();
10597     SetGameInfo();
10598
10599     StartAnalysisClock();
10600     GetTimeMark(&lastNodeCountTime);
10601     lastNodeCount = 0;
10602 }
10603
10604 void
10605 AnalyzeFileEvent()
10606 {
10607     if (appData.noChessProgram || gameMode == AnalyzeFile)
10608       return;
10609
10610     if (gameMode != AnalyzeMode) {
10611         EditGameEvent();
10612         if (gameMode != EditGame) return;
10613         ResurrectChessProgram();
10614         SendToProgram("analyze\n", &first);
10615         first.analyzing = TRUE;
10616         /*first.maybeThinking = TRUE;*/
10617         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
10618         EngineOutputPopUp();
10619     }
10620     gameMode = AnalyzeFile;
10621     pausing = FALSE;
10622     ModeHighlight();
10623     SetGameInfo();
10624
10625     StartAnalysisClock();
10626     GetTimeMark(&lastNodeCountTime);
10627     lastNodeCount = 0;
10628 }
10629
10630 void
10631 MachineWhiteEvent()
10632 {
10633     char buf[MSG_SIZ];
10634     char *bookHit = NULL;
10635
10636     if (appData.noChessProgram || (gameMode == MachinePlaysWhite))
10637       return;
10638
10639
10640     if (gameMode == PlayFromGameFile ||
10641         gameMode == TwoMachinesPlay  ||
10642         gameMode == Training         ||
10643         gameMode == AnalyzeMode      ||
10644         gameMode == EndOfGame)
10645         EditGameEvent();
10646
10647     if (gameMode == EditPosition)
10648         EditPositionDone();
10649
10650     if (!WhiteOnMove(currentMove)) {
10651         DisplayError(_("It is not White's turn"), 0);
10652         return;
10653     }
10654
10655     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
10656       ExitAnalyzeMode();
10657
10658     if (gameMode == EditGame || gameMode == AnalyzeMode ||
10659         gameMode == AnalyzeFile)
10660         TruncateGame();
10661
10662     ResurrectChessProgram();    /* in case it isn't running */
10663     if(gameMode == BeginningOfGame) { /* [HGM] time odds: to get right odds in human mode */
10664         gameMode = MachinePlaysWhite;
10665         ResetClocks();
10666     } else
10667     gameMode = MachinePlaysWhite;
10668     pausing = FALSE;
10669     ModeHighlight();
10670     SetGameInfo();
10671     sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
10672     DisplayTitle(buf);
10673     if (first.sendName) {
10674       sprintf(buf, "name %s\n", gameInfo.black);
10675       SendToProgram(buf, &first);
10676     }
10677     if (first.sendTime) {
10678       if (first.useColors) {
10679         SendToProgram("black\n", &first); /*gnu kludge*/
10680       }
10681       SendTimeRemaining(&first, TRUE);
10682     }
10683     if (first.useColors) {
10684       SendToProgram("white\n", &first); // [HGM] book: send 'go' separately
10685     }
10686     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
10687     SetMachineThinkingEnables();
10688     first.maybeThinking = TRUE;
10689     StartClocks();
10690     firstMove = FALSE;
10691
10692     if (appData.autoFlipView && !flipView) {
10693       flipView = !flipView;
10694       DrawPosition(FALSE, NULL);
10695       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
10696     }
10697
10698     if(bookHit) { // [HGM] book: simulate book reply
10699         static char bookMove[MSG_SIZ]; // a bit generous?
10700
10701         programStats.nodes = programStats.depth = programStats.time =
10702         programStats.score = programStats.got_only_move = 0;
10703         sprintf(programStats.movelist, "%s (xbook)", bookHit);
10704
10705         strcpy(bookMove, "move ");
10706         strcat(bookMove, bookHit);
10707         HandleMachineMove(bookMove, &first);
10708     }
10709 }
10710
10711 void
10712 MachineBlackEvent()
10713 {
10714     char buf[MSG_SIZ];
10715    char *bookHit = NULL;
10716
10717     if (appData.noChessProgram || (gameMode == MachinePlaysBlack))
10718         return;
10719
10720
10721     if (gameMode == PlayFromGameFile ||
10722         gameMode == TwoMachinesPlay  ||
10723         gameMode == Training         ||
10724         gameMode == AnalyzeMode      ||
10725         gameMode == EndOfGame)
10726         EditGameEvent();
10727
10728     if (gameMode == EditPosition)
10729         EditPositionDone();
10730
10731     if (WhiteOnMove(currentMove)) {
10732         DisplayError(_("It is not Black's turn"), 0);
10733         return;
10734     }
10735
10736     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
10737       ExitAnalyzeMode();
10738
10739     if (gameMode == EditGame || gameMode == AnalyzeMode ||
10740         gameMode == AnalyzeFile)
10741         TruncateGame();
10742
10743     ResurrectChessProgram();    /* in case it isn't running */
10744     gameMode = MachinePlaysBlack;
10745     pausing = FALSE;
10746     ModeHighlight();
10747     SetGameInfo();
10748     sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
10749     DisplayTitle(buf);
10750     if (first.sendName) {
10751       sprintf(buf, "name %s\n", gameInfo.white);
10752       SendToProgram(buf, &first);
10753     }
10754     if (first.sendTime) {
10755       if (first.useColors) {
10756         SendToProgram("white\n", &first); /*gnu kludge*/
10757       }
10758       SendTimeRemaining(&first, FALSE);
10759     }
10760     if (first.useColors) {
10761       SendToProgram("black\n", &first); // [HGM] book: 'go' sent separately
10762     }
10763     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
10764     SetMachineThinkingEnables();
10765     first.maybeThinking = TRUE;
10766     StartClocks();
10767
10768     if (appData.autoFlipView && flipView) {
10769       flipView = !flipView;
10770       DrawPosition(FALSE, NULL);
10771       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
10772     }
10773     if(bookHit) { // [HGM] book: simulate book reply
10774         static char bookMove[MSG_SIZ]; // a bit generous?
10775
10776         programStats.nodes = programStats.depth = programStats.time =
10777         programStats.score = programStats.got_only_move = 0;
10778         sprintf(programStats.movelist, "%s (xbook)", bookHit);
10779
10780         strcpy(bookMove, "move ");
10781         strcat(bookMove, bookHit);
10782         HandleMachineMove(bookMove, &first);
10783     }
10784 }
10785
10786
10787 void
10788 DisplayTwoMachinesTitle()
10789 {
10790     char buf[MSG_SIZ];
10791     if (appData.matchGames > 0) {
10792         if (first.twoMachinesColor[0] == 'w') {
10793             sprintf(buf, "%s vs. %s (%d-%d-%d)",
10794                     gameInfo.white, gameInfo.black,
10795                     first.matchWins, second.matchWins,
10796                     matchGame - 1 - (first.matchWins + second.matchWins));
10797         } else {
10798             sprintf(buf, "%s vs. %s (%d-%d-%d)",
10799                     gameInfo.white, gameInfo.black,
10800                     second.matchWins, first.matchWins,
10801                     matchGame - 1 - (first.matchWins + second.matchWins));
10802         }
10803     } else {
10804         sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
10805     }
10806     DisplayTitle(buf);
10807 }
10808
10809 void
10810 TwoMachinesEvent P((void))
10811 {
10812     int i;
10813     char buf[MSG_SIZ];
10814     ChessProgramState *onmove;
10815     char *bookHit = NULL;
10816
10817     if (appData.noChessProgram) return;
10818
10819     switch (gameMode) {
10820       case TwoMachinesPlay:
10821         return;
10822       case MachinePlaysWhite:
10823       case MachinePlaysBlack:
10824         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
10825             DisplayError(_("Wait until your turn,\nor select Move Now"), 0);
10826             return;
10827         }
10828         /* fall through */
10829       case BeginningOfGame:
10830       case PlayFromGameFile:
10831       case EndOfGame:
10832         EditGameEvent();
10833         if (gameMode != EditGame) return;
10834         break;
10835       case EditPosition:
10836         EditPositionDone();
10837         break;
10838       case AnalyzeMode:
10839       case AnalyzeFile:
10840         ExitAnalyzeMode();
10841         break;
10842       case EditGame:
10843       default:
10844         break;
10845     }
10846
10847     forwardMostMove = currentMove;
10848     ResurrectChessProgram();    /* in case first program isn't running */
10849
10850     if (second.pr == NULL) {
10851         StartChessProgram(&second);
10852         if (second.protocolVersion == 1) {
10853           TwoMachinesEventIfReady();
10854         } else {
10855           /* kludge: allow timeout for initial "feature" command */
10856           FreezeUI();
10857           DisplayMessage("", _("Starting second chess program"));
10858           ScheduleDelayedEvent(TwoMachinesEventIfReady, FEATURE_TIMEOUT);
10859         }
10860         return;
10861     }
10862     DisplayMessage("", "");
10863     InitChessProgram(&second, FALSE);
10864     SendToProgram("force\n", &second);
10865     if (startedFromSetupPosition) {
10866         SendBoard(&second, backwardMostMove);
10867     if (appData.debugMode) {
10868         fprintf(debugFP, "Two Machines\n");
10869     }
10870     }
10871     for (i = backwardMostMove; i < forwardMostMove; i++) {
10872         SendMoveToProgram(i, &second);
10873     }
10874
10875     gameMode = TwoMachinesPlay;
10876     pausing = FALSE;
10877     ModeHighlight();
10878     SetGameInfo();
10879     DisplayTwoMachinesTitle();
10880     firstMove = TRUE;
10881     if ((first.twoMachinesColor[0] == 'w') == WhiteOnMove(forwardMostMove)) {
10882         onmove = &first;
10883     } else {
10884         onmove = &second;
10885     }
10886
10887     SendToProgram(first.computerString, &first);
10888     if (first.sendName) {
10889       sprintf(buf, "name %s\n", second.tidy);
10890       SendToProgram(buf, &first);
10891     }
10892     SendToProgram(second.computerString, &second);
10893     if (second.sendName) {
10894       sprintf(buf, "name %s\n", first.tidy);
10895       SendToProgram(buf, &second);
10896     }
10897
10898     ResetClocks();
10899     if (!first.sendTime || !second.sendTime) {
10900         timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
10901         timeRemaining[1][forwardMostMove] = blackTimeRemaining;
10902     }
10903     if (onmove->sendTime) {
10904       if (onmove->useColors) {
10905         SendToProgram(onmove->other->twoMachinesColor, onmove); /*gnu kludge*/
10906       }
10907       SendTimeRemaining(onmove, WhiteOnMove(forwardMostMove));
10908     }
10909     if (onmove->useColors) {
10910       SendToProgram(onmove->twoMachinesColor, onmove);
10911     }
10912     bookHit = SendMoveToBookUser(forwardMostMove-1, onmove, TRUE); // [HGM] book: send go or retrieve book move
10913 //    SendToProgram("go\n", onmove);
10914     onmove->maybeThinking = TRUE;
10915     SetMachineThinkingEnables();
10916
10917     StartClocks();
10918
10919     if(bookHit) { // [HGM] book: simulate book reply
10920         static char bookMove[MSG_SIZ]; // a bit generous?
10921
10922         programStats.nodes = programStats.depth = programStats.time =
10923         programStats.score = programStats.got_only_move = 0;
10924         sprintf(programStats.movelist, "%s (xbook)", bookHit);
10925
10926         strcpy(bookMove, "move ");
10927         strcat(bookMove, bookHit);
10928         HandleMachineMove(bookMove, &first);
10929     }
10930 }
10931
10932 void
10933 TrainingEvent()
10934 {
10935     if (gameMode == Training) {
10936       SetTrainingModeOff();
10937       gameMode = PlayFromGameFile;
10938       DisplayMessage("", _("Training mode off"));
10939     } else {
10940       gameMode = Training;
10941       animateTraining = appData.animate;
10942
10943       /* make sure we are not already at the end of the game */
10944       if (currentMove < forwardMostMove) {
10945         SetTrainingModeOn();
10946         DisplayMessage("", _("Training mode on"));
10947       } else {
10948         gameMode = PlayFromGameFile;
10949         DisplayError(_("Already at end of game"), 0);
10950       }
10951     }
10952     ModeHighlight();
10953 }
10954
10955 void
10956 IcsClientEvent()
10957 {
10958     if (!appData.icsActive) return;
10959     switch (gameMode) {
10960       case IcsPlayingWhite:
10961       case IcsPlayingBlack:
10962       case IcsObserving:
10963       case IcsIdle:
10964       case BeginningOfGame:
10965       case IcsExamining:
10966         return;
10967
10968       case EditGame:
10969         break;
10970
10971       case EditPosition:
10972         EditPositionDone();
10973         break;
10974
10975       case AnalyzeMode:
10976       case AnalyzeFile:
10977         ExitAnalyzeMode();
10978         break;
10979
10980       default:
10981         EditGameEvent();
10982         break;
10983     }
10984
10985     gameMode = IcsIdle;
10986     ModeHighlight();
10987     return;
10988 }
10989
10990
10991 void
10992 EditGameEvent()
10993 {
10994     int i;
10995
10996     switch (gameMode) {
10997       case Training:
10998         SetTrainingModeOff();
10999         break;
11000       case MachinePlaysWhite:
11001       case MachinePlaysBlack:
11002       case BeginningOfGame:
11003         SendToProgram("force\n", &first);
11004         SetUserThinkingEnables();
11005         break;
11006       case PlayFromGameFile:
11007         (void) StopLoadGameTimer();
11008         if (gameFileFP != NULL) {
11009             gameFileFP = NULL;
11010         }
11011         break;
11012       case EditPosition:
11013         EditPositionDone();
11014         break;
11015       case AnalyzeMode:
11016       case AnalyzeFile:
11017         ExitAnalyzeMode();
11018         SendToProgram("force\n", &first);
11019         break;
11020       case TwoMachinesPlay:
11021         GameEnds((ChessMove) 0, NULL, GE_PLAYER);
11022         ResurrectChessProgram();
11023         SetUserThinkingEnables();
11024         break;
11025       case EndOfGame:
11026         ResurrectChessProgram();
11027         break;
11028       case IcsPlayingBlack:
11029       case IcsPlayingWhite:
11030         DisplayError(_("Warning: You are still playing a game"), 0);
11031         break;
11032       case IcsObserving:
11033         DisplayError(_("Warning: You are still observing a game"), 0);
11034         break;
11035       case IcsExamining:
11036         DisplayError(_("Warning: You are still examining a game"), 0);
11037         break;
11038       case IcsIdle:
11039         break;
11040       case EditGame:
11041       default:
11042         return;
11043     }
11044
11045     pausing = FALSE;
11046     StopClocks();
11047     first.offeredDraw = second.offeredDraw = 0;
11048
11049     if (gameMode == PlayFromGameFile) {
11050         whiteTimeRemaining = timeRemaining[0][currentMove];
11051         blackTimeRemaining = timeRemaining[1][currentMove];
11052         DisplayTitle("");
11053     }
11054
11055     if (gameMode == MachinePlaysWhite ||
11056         gameMode == MachinePlaysBlack ||
11057         gameMode == TwoMachinesPlay ||
11058         gameMode == EndOfGame) {
11059         i = forwardMostMove;
11060         while (i > currentMove) {
11061             SendToProgram("undo\n", &first);
11062             i--;
11063         }
11064         whiteTimeRemaining = timeRemaining[0][currentMove];
11065         blackTimeRemaining = timeRemaining[1][currentMove];
11066         DisplayBothClocks();
11067         if (whiteFlag || blackFlag) {
11068             whiteFlag = blackFlag = 0;
11069         }
11070         DisplayTitle("");
11071     }
11072
11073     gameMode = EditGame;
11074     ModeHighlight();
11075     SetGameInfo();
11076 }
11077
11078
11079 void
11080 EditPositionEvent()
11081 {
11082     if (gameMode == EditPosition) {
11083         EditGameEvent();
11084         return;
11085     }
11086
11087     EditGameEvent();
11088     if (gameMode != EditGame) return;
11089
11090     gameMode = EditPosition;
11091     ModeHighlight();
11092     SetGameInfo();
11093     if (currentMove > 0)
11094       CopyBoard(boards[0], boards[currentMove]);
11095
11096     blackPlaysFirst = !WhiteOnMove(currentMove);
11097     ResetClocks();
11098     currentMove = forwardMostMove = backwardMostMove = 0;
11099     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
11100     DisplayMove(-1);
11101 }
11102
11103 void
11104 ExitAnalyzeMode()
11105 {
11106     /* [DM] icsEngineAnalyze - possible call from other functions */
11107     if (appData.icsEngineAnalyze) {
11108         appData.icsEngineAnalyze = FALSE;
11109
11110         DisplayMessage("",_("Close ICS engine analyze..."));
11111     }
11112     if (first.analysisSupport && first.analyzing) {
11113       SendToProgram("exit\n", &first);
11114       first.analyzing = FALSE;
11115     }
11116     thinkOutput[0] = NULLCHAR;
11117 }
11118
11119 void
11120 EditPositionDone()
11121 {
11122     int king = gameInfo.variant == VariantKnightmate ? WhiteUnicorn : WhiteKing;
11123
11124     startedFromSetupPosition = TRUE;
11125     InitChessProgram(&first, FALSE);
11126     castlingRights[0][2] = castlingRights[0][5] = BOARD_WIDTH>>1;
11127     if(boards[0][0][BOARD_WIDTH>>1] == king) {
11128         castlingRights[0][1] = boards[0][0][BOARD_LEFT] == WhiteRook ? 0 : -1;
11129         castlingRights[0][0] = boards[0][0][BOARD_RGHT-1] == WhiteRook ? BOARD_RGHT-1 : -1;
11130     } else castlingRights[0][2] = -1;
11131     if(boards[0][BOARD_HEIGHT-1][BOARD_WIDTH>>1] == WHITE_TO_BLACK king) {
11132         castlingRights[0][4] = boards[0][BOARD_HEIGHT-1][BOARD_LEFT] == BlackRook ? 0 : -1;
11133         castlingRights[0][3] = boards[0][BOARD_HEIGHT-1][BOARD_RGHT-1] == BlackRook ? BOARD_RGHT-1 : -1;
11134     } else castlingRights[0][5] = -1;
11135     SendToProgram("force\n", &first);
11136     if (blackPlaysFirst) {
11137         strcpy(moveList[0], "");
11138         strcpy(parseList[0], "");
11139         currentMove = forwardMostMove = backwardMostMove = 1;
11140         CopyBoard(boards[1], boards[0]);
11141         /* [HGM] copy rights as well, as this code is also used after pasting a FEN */
11142         { int i;
11143           epStatus[1] = epStatus[0];
11144           for(i=0; i<nrCastlingRights; i++) castlingRights[1][i] = castlingRights[0][i];
11145         }
11146     } else {
11147         currentMove = forwardMostMove = backwardMostMove = 0;
11148     }
11149     SendBoard(&first, forwardMostMove);
11150     if (appData.debugMode) {
11151         fprintf(debugFP, "EditPosDone\n");
11152     }
11153     DisplayTitle("");
11154     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
11155     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
11156     gameMode = EditGame;
11157     ModeHighlight();
11158     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
11159     ClearHighlights(); /* [AS] */
11160 }
11161
11162 /* Pause for `ms' milliseconds */
11163 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
11164 void
11165 TimeDelay(ms)
11166      long ms;
11167 {
11168     TimeMark m1, m2;
11169
11170     GetTimeMark(&m1);
11171     do {
11172         GetTimeMark(&m2);
11173     } while (SubtractTimeMarks(&m2, &m1) < ms);
11174 }
11175
11176 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
11177 void
11178 SendMultiLineToICS(buf)
11179      char *buf;
11180 {
11181     char temp[MSG_SIZ+1], *p;
11182     int len;
11183
11184     len = strlen(buf);
11185     if (len > MSG_SIZ)
11186       len = MSG_SIZ;
11187
11188     strncpy(temp, buf, len);
11189     temp[len] = 0;
11190
11191     p = temp;
11192     while (*p) {
11193         if (*p == '\n' || *p == '\r')
11194           *p = ' ';
11195         ++p;
11196     }
11197
11198     strcat(temp, "\n");
11199     SendToICS(temp);
11200     SendToPlayer(temp, strlen(temp));
11201 }
11202
11203 void
11204 SetWhiteToPlayEvent()
11205 {
11206     if (gameMode == EditPosition) {
11207         blackPlaysFirst = FALSE;
11208         DisplayBothClocks();    /* works because currentMove is 0 */
11209     } else if (gameMode == IcsExamining) {
11210         SendToICS(ics_prefix);
11211         SendToICS("tomove white\n");
11212     }
11213 }
11214
11215 void
11216 SetBlackToPlayEvent()
11217 {
11218     if (gameMode == EditPosition) {
11219         blackPlaysFirst = TRUE;
11220         currentMove = 1;        /* kludge */
11221         DisplayBothClocks();
11222         currentMove = 0;
11223     } else if (gameMode == IcsExamining) {
11224         SendToICS(ics_prefix);
11225         SendToICS("tomove black\n");
11226     }
11227 }
11228
11229 void
11230 EditPositionMenuEvent(selection, x, y)
11231      ChessSquare selection;
11232      int x, y;
11233 {
11234     char buf[MSG_SIZ];
11235     ChessSquare piece = boards[0][y][x];
11236
11237     if (gameMode != EditPosition && gameMode != IcsExamining) return;
11238
11239     switch (selection) {
11240       case ClearBoard:
11241         if (gameMode == IcsExamining && ics_type == ICS_FICS) {
11242             SendToICS(ics_prefix);
11243             SendToICS("bsetup clear\n");
11244         } else if (gameMode == IcsExamining && ics_type == ICS_ICC) {
11245             SendToICS(ics_prefix);
11246             SendToICS("clearboard\n");
11247         } else {
11248             for (x = 0; x < BOARD_WIDTH; x++) { ChessSquare p = EmptySquare;
11249                 if(x == BOARD_LEFT-1 || x == BOARD_RGHT) p = (ChessSquare) 0; /* [HGM] holdings */
11250                 for (y = 0; y < BOARD_HEIGHT; y++) {
11251                     if (gameMode == IcsExamining) {
11252                         if (boards[currentMove][y][x] != EmptySquare) {
11253                             sprintf(buf, "%sx@%c%c\n", ics_prefix,
11254                                     AAA + x, ONE + y);
11255                             SendToICS(buf);
11256                         }
11257                     } else {
11258                         boards[0][y][x] = p;
11259                     }
11260                 }
11261             }
11262         }
11263         if (gameMode == EditPosition) {
11264             DrawPosition(FALSE, boards[0]);
11265         }
11266         break;
11267
11268       case WhitePlay:
11269         SetWhiteToPlayEvent();
11270         break;
11271
11272       case BlackPlay:
11273         SetBlackToPlayEvent();
11274         break;
11275
11276       case EmptySquare:
11277         if (gameMode == IcsExamining) {
11278             sprintf(buf, "%sx@%c%c\n", ics_prefix, AAA + x, ONE + y);
11279             SendToICS(buf);
11280         } else {
11281             boards[0][y][x] = EmptySquare;
11282             DrawPosition(FALSE, boards[0]);
11283         }
11284         break;
11285
11286       case PromotePiece:
11287         if(piece >= (int)WhitePawn && piece < (int)WhiteMan ||
11288            piece >= (int)BlackPawn && piece < (int)BlackMan   ) {
11289             selection = (ChessSquare) (PROMOTED piece);
11290         } else if(piece == EmptySquare) selection = WhiteSilver;
11291         else selection = (ChessSquare)((int)piece - 1);
11292         goto defaultlabel;
11293
11294       case DemotePiece:
11295         if(piece > (int)WhiteMan && piece <= (int)WhiteKing ||
11296            piece > (int)BlackMan && piece <= (int)BlackKing   ) {
11297             selection = (ChessSquare) (DEMOTED piece);
11298         } else if(piece == EmptySquare) selection = BlackSilver;
11299         else selection = (ChessSquare)((int)piece + 1);
11300         goto defaultlabel;
11301
11302       case WhiteQueen:
11303       case BlackQueen:
11304         if(gameInfo.variant == VariantShatranj ||
11305            gameInfo.variant == VariantXiangqi  ||
11306            gameInfo.variant == VariantCourier    )
11307             selection = (ChessSquare)((int)selection - (int)WhiteQueen + (int)WhiteFerz);
11308         goto defaultlabel;
11309
11310       case WhiteKing:
11311       case BlackKing:
11312         if(gameInfo.variant == VariantXiangqi)
11313             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteWazir);
11314         if(gameInfo.variant == VariantKnightmate)
11315             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteUnicorn);
11316       default:
11317         defaultlabel:
11318         if (gameMode == IcsExamining) {
11319             sprintf(buf, "%s%c@%c%c\n", ics_prefix,
11320                     PieceToChar(selection), AAA + x, ONE + y);
11321             SendToICS(buf);
11322         } else {
11323             boards[0][y][x] = selection;
11324             DrawPosition(FALSE, boards[0]);
11325         }
11326         break;
11327     }
11328 }
11329
11330
11331 void
11332 DropMenuEvent(selection, x, y)
11333      ChessSquare selection;
11334      int x, y;
11335 {
11336     ChessMove moveType;
11337
11338     switch (gameMode) {
11339       case IcsPlayingWhite:
11340       case MachinePlaysBlack:
11341         if (!WhiteOnMove(currentMove)) {
11342             DisplayMoveError(_("It is Black's turn"));
11343             return;
11344         }
11345         moveType = WhiteDrop;
11346         break;
11347       case IcsPlayingBlack:
11348       case MachinePlaysWhite:
11349         if (WhiteOnMove(currentMove)) {
11350             DisplayMoveError(_("It is White's turn"));
11351             return;
11352         }
11353         moveType = BlackDrop;
11354         break;
11355       case EditGame:
11356         moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
11357         break;
11358       default:
11359         return;
11360     }
11361
11362     if (moveType == BlackDrop && selection < BlackPawn) {
11363       selection = (ChessSquare) ((int) selection
11364                                  + (int) BlackPawn - (int) WhitePawn);
11365     }
11366     if (boards[currentMove][y][x] != EmptySquare) {
11367         DisplayMoveError(_("That square is occupied"));
11368         return;
11369     }
11370
11371     FinishMove(moveType, (int) selection, DROP_RANK, x, y, NULLCHAR);
11372 }
11373
11374 void
11375 AcceptEvent()
11376 {
11377     /* Accept a pending offer of any kind from opponent */
11378
11379     if (appData.icsActive) {
11380         SendToICS(ics_prefix);
11381         SendToICS("accept\n");
11382     } else if (cmailMsgLoaded) {
11383         if (currentMove == cmailOldMove &&
11384             commentList[cmailOldMove] != NULL &&
11385             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
11386                    "Black offers a draw" : "White offers a draw")) {
11387             TruncateGame();
11388             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
11389             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
11390         } else {
11391             DisplayError(_("There is no pending offer on this move"), 0);
11392             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
11393         }
11394     } else {
11395         /* Not used for offers from chess program */
11396     }
11397 }
11398
11399 void
11400 DeclineEvent()
11401 {
11402     /* Decline a pending offer of any kind from opponent */
11403
11404     if (appData.icsActive) {
11405         SendToICS(ics_prefix);
11406         SendToICS("decline\n");
11407     } else if (cmailMsgLoaded) {
11408         if (currentMove == cmailOldMove &&
11409             commentList[cmailOldMove] != NULL &&
11410             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
11411                    "Black offers a draw" : "White offers a draw")) {
11412 #ifdef NOTDEF
11413             AppendComment(cmailOldMove, "Draw declined");
11414             DisplayComment(cmailOldMove - 1, "Draw declined");
11415 #endif /*NOTDEF*/
11416         } else {
11417             DisplayError(_("There is no pending offer on this move"), 0);
11418         }
11419     } else {
11420         /* Not used for offers from chess program */
11421     }
11422 }
11423
11424 void
11425 RematchEvent()
11426 {
11427     /* Issue ICS rematch command */
11428     if (appData.icsActive) {
11429         SendToICS(ics_prefix);
11430         SendToICS("rematch\n");
11431     }
11432 }
11433
11434 void
11435 CallFlagEvent()
11436 {
11437     /* Call your opponent's flag (claim a win on time) */
11438     if (appData.icsActive) {
11439         SendToICS(ics_prefix);
11440         SendToICS("flag\n");
11441     } else {
11442         switch (gameMode) {
11443           default:
11444             return;
11445           case MachinePlaysWhite:
11446             if (whiteFlag) {
11447                 if (blackFlag)
11448                   GameEnds(GameIsDrawn, "Both players ran out of time",
11449                            GE_PLAYER);
11450                 else
11451                   GameEnds(BlackWins, "Black wins on time", GE_PLAYER);
11452             } else {
11453                 DisplayError(_("Your opponent is not out of time"), 0);
11454             }
11455             break;
11456           case MachinePlaysBlack:
11457             if (blackFlag) {
11458                 if (whiteFlag)
11459                   GameEnds(GameIsDrawn, "Both players ran out of time",
11460                            GE_PLAYER);
11461                 else
11462                   GameEnds(WhiteWins, "White wins on time", GE_PLAYER);
11463             } else {
11464                 DisplayError(_("Your opponent is not out of time"), 0);
11465             }
11466             break;
11467         }
11468     }
11469 }
11470
11471 void
11472 DrawEvent()
11473 {
11474     /* Offer draw or accept pending draw offer from opponent */
11475
11476     if (appData.icsActive) {
11477         /* Note: tournament rules require draw offers to be
11478            made after you make your move but before you punch
11479            your clock.  Currently ICS doesn't let you do that;
11480            instead, you immediately punch your clock after making
11481            a move, but you can offer a draw at any time. */
11482
11483         SendToICS(ics_prefix);
11484         SendToICS("draw\n");
11485     } else if (cmailMsgLoaded) {
11486         if (currentMove == cmailOldMove &&
11487             commentList[cmailOldMove] != NULL &&
11488             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
11489                    "Black offers a draw" : "White offers a draw")) {
11490             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
11491             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
11492         } else if (currentMove == cmailOldMove + 1) {
11493             char *offer = WhiteOnMove(cmailOldMove) ?
11494               "White offers a draw" : "Black offers a draw";
11495             AppendComment(currentMove, offer);
11496             DisplayComment(currentMove - 1, offer);
11497             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_DRAW;
11498         } else {
11499             DisplayError(_("You must make your move before offering a draw"), 0);
11500             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
11501         }
11502     } else if (first.offeredDraw) {
11503         GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
11504     } else {
11505         if (first.sendDrawOffers) {
11506             SendToProgram("draw\n", &first);
11507             userOfferedDraw = TRUE;
11508         }
11509     }
11510 }
11511
11512 void
11513 AdjournEvent()
11514 {
11515     /* Offer Adjourn or accept pending Adjourn offer from opponent */
11516
11517     if (appData.icsActive) {
11518         SendToICS(ics_prefix);
11519         SendToICS("adjourn\n");
11520     } else {
11521         /* Currently GNU Chess doesn't offer or accept Adjourns */
11522     }
11523 }
11524
11525
11526 void
11527 AbortEvent()
11528 {
11529     /* Offer Abort or accept pending Abort offer from opponent */
11530
11531     if (appData.icsActive) {
11532         SendToICS(ics_prefix);
11533         SendToICS("abort\n");
11534     } else {
11535         GameEnds(GameUnfinished, "Game aborted", GE_PLAYER);
11536     }
11537 }
11538
11539 void
11540 ResignEvent()
11541 {
11542     /* Resign.  You can do this even if it's not your turn. */
11543
11544     if (appData.icsActive) {
11545         SendToICS(ics_prefix);
11546         SendToICS("resign\n");
11547     } else {
11548         switch (gameMode) {
11549           case MachinePlaysWhite:
11550             GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
11551             break;
11552           case MachinePlaysBlack:
11553             GameEnds(BlackWins, "White resigns", GE_PLAYER);
11554             break;
11555           case EditGame:
11556             if (cmailMsgLoaded) {
11557                 TruncateGame();
11558                 if (WhiteOnMove(cmailOldMove)) {
11559                     GameEnds(BlackWins, "White resigns", GE_PLAYER);
11560                 } else {
11561                     GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
11562                 }
11563                 cmailMoveType[lastLoadGameNumber - 1] = CMAIL_RESIGN;
11564             }
11565             break;
11566           default:
11567             break;
11568         }
11569     }
11570 }
11571
11572
11573 void
11574 StopObservingEvent()
11575 {
11576     /* Stop observing current games */
11577     SendToICS(ics_prefix);
11578     SendToICS("unobserve\n");
11579 }
11580
11581 void
11582 StopExaminingEvent()
11583 {
11584     /* Stop observing current game */
11585     SendToICS(ics_prefix);
11586     SendToICS("unexamine\n");
11587 }
11588
11589 void
11590 ForwardInner(target)
11591      int target;
11592 {
11593     int limit;
11594
11595     if (appData.debugMode)
11596         fprintf(debugFP, "ForwardInner(%d), current %d, forward %d\n",
11597                 target, currentMove, forwardMostMove);
11598
11599     if (gameMode == EditPosition)
11600       return;
11601
11602     if (gameMode == PlayFromGameFile && !pausing)
11603       PauseEvent();
11604
11605     if (gameMode == IcsExamining && pausing)
11606       limit = pauseExamForwardMostMove;
11607     else
11608       limit = forwardMostMove;
11609
11610     if (target > limit) target = limit;
11611
11612     if (target > 0 && moveList[target - 1][0]) {
11613         int fromX, fromY, toX, toY;
11614         toX = moveList[target - 1][2] - AAA;
11615         toY = moveList[target - 1][3] - ONE;
11616         if (moveList[target - 1][1] == '@') {
11617             if (appData.highlightLastMove) {
11618                 SetHighlights(-1, -1, toX, toY);
11619             }
11620         } else {
11621             fromX = moveList[target - 1][0] - AAA;
11622             fromY = moveList[target - 1][1] - ONE;
11623             if (target == currentMove + 1) {
11624                 AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
11625             }
11626             if (appData.highlightLastMove) {
11627                 SetHighlights(fromX, fromY, toX, toY);
11628             }
11629         }
11630     }
11631     if (gameMode == EditGame || gameMode == AnalyzeMode ||
11632         gameMode == Training || gameMode == PlayFromGameFile ||
11633         gameMode == AnalyzeFile) {
11634         while (currentMove < target) {
11635             SendMoveToProgram(currentMove++, &first);
11636         }
11637     } else {
11638         currentMove = target;
11639     }
11640
11641     if (gameMode == EditGame || gameMode == EndOfGame) {
11642         whiteTimeRemaining = timeRemaining[0][currentMove];
11643         blackTimeRemaining = timeRemaining[1][currentMove];
11644     }
11645     DisplayBothClocks();
11646     DisplayMove(currentMove - 1);
11647     DrawPosition(FALSE, boards[currentMove]);
11648     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
11649     if ( !matchMode && gameMode != Training) { // [HGM] PV info: routine tests if empty
11650         DisplayComment(currentMove - 1, commentList[currentMove]);
11651     }
11652 }
11653
11654
11655 void
11656 ForwardEvent()
11657 {
11658     if (gameMode == IcsExamining && !pausing) {
11659         SendToICS(ics_prefix);
11660         SendToICS("forward\n");
11661     } else {
11662         ForwardInner(currentMove + 1);
11663     }
11664 }
11665
11666 void
11667 ToEndEvent()
11668 {
11669     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
11670         /* to optimze, we temporarily turn off analysis mode while we feed
11671          * the remaining moves to the engine. Otherwise we get analysis output
11672          * after each move.
11673          */
11674         if (first.analysisSupport) {
11675           SendToProgram("exit\nforce\n", &first);
11676           first.analyzing = FALSE;
11677         }
11678     }
11679
11680     if (gameMode == IcsExamining && !pausing) {
11681         SendToICS(ics_prefix);
11682         SendToICS("forward 999999\n");
11683     } else {
11684         ForwardInner(forwardMostMove);
11685     }
11686
11687     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
11688         /* we have fed all the moves, so reactivate analysis mode */
11689         SendToProgram("analyze\n", &first);
11690         first.analyzing = TRUE;
11691         /*first.maybeThinking = TRUE;*/
11692         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
11693     }
11694 }
11695
11696 void
11697 BackwardInner(target)
11698      int target;
11699 {
11700     int full_redraw = TRUE; /* [AS] Was FALSE, had to change it! */
11701
11702     if (appData.debugMode)
11703         fprintf(debugFP, "BackwardInner(%d), current %d, forward %d\n",
11704                 target, currentMove, forwardMostMove);
11705
11706     if (gameMode == EditPosition) return;
11707     if (currentMove <= backwardMostMove) {
11708         ClearHighlights();
11709         DrawPosition(full_redraw, boards[currentMove]);
11710         return;
11711     }
11712     if (gameMode == PlayFromGameFile && !pausing)
11713       PauseEvent();
11714
11715     if (moveList[target][0]) {
11716         int fromX, fromY, toX, toY;
11717         toX = moveList[target][2] - AAA;
11718         toY = moveList[target][3] - ONE;
11719         if (moveList[target][1] == '@') {
11720             if (appData.highlightLastMove) {
11721                 SetHighlights(-1, -1, toX, toY);
11722             }
11723         } else {
11724             fromX = moveList[target][0] - AAA;
11725             fromY = moveList[target][1] - ONE;
11726             if (target == currentMove - 1) {
11727                 AnimateMove(boards[currentMove], toX, toY, fromX, fromY);
11728             }
11729             if (appData.highlightLastMove) {
11730                 SetHighlights(fromX, fromY, toX, toY);
11731             }
11732         }
11733     }
11734     if (gameMode == EditGame || gameMode==AnalyzeMode ||
11735         gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
11736         while (currentMove > target) {
11737             SendToProgram("undo\n", &first);
11738             currentMove--;
11739         }
11740     } else {
11741         currentMove = target;
11742     }
11743
11744     if (gameMode == EditGame || gameMode == EndOfGame) {
11745         whiteTimeRemaining = timeRemaining[0][currentMove];
11746         blackTimeRemaining = timeRemaining[1][currentMove];
11747     }
11748     DisplayBothClocks();
11749     DisplayMove(currentMove - 1);
11750     DrawPosition(full_redraw, boards[currentMove]);
11751     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
11752     // [HGM] PV info: routine tests if comment empty
11753     DisplayComment(currentMove - 1, commentList[currentMove]);
11754 }
11755
11756 void
11757 BackwardEvent()
11758 {
11759     if (gameMode == IcsExamining && !pausing) {
11760         SendToICS(ics_prefix);
11761         SendToICS("backward\n");
11762     } else {
11763         BackwardInner(currentMove - 1);
11764     }
11765 }
11766
11767 void
11768 ToStartEvent()
11769 {
11770     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
11771         /* to optimze, we temporarily turn off analysis mode while we undo
11772          * all the moves. Otherwise we get analysis output after each undo.
11773          */
11774         if (first.analysisSupport) {
11775           SendToProgram("exit\nforce\n", &first);
11776           first.analyzing = FALSE;
11777         }
11778     }
11779
11780     if (gameMode == IcsExamining && !pausing) {
11781         SendToICS(ics_prefix);
11782         SendToICS("backward 999999\n");
11783     } else {
11784         BackwardInner(backwardMostMove);
11785     }
11786
11787     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
11788         /* we have fed all the moves, so reactivate analysis mode */
11789         SendToProgram("analyze\n", &first);
11790         first.analyzing = TRUE;
11791         /*first.maybeThinking = TRUE;*/
11792         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
11793     }
11794 }
11795
11796 void
11797 ToNrEvent(int to)
11798 {
11799   if (gameMode == PlayFromGameFile && !pausing) PauseEvent();
11800   if (to >= forwardMostMove) to = forwardMostMove;
11801   if (to <= backwardMostMove) to = backwardMostMove;
11802   if (to < currentMove) {
11803     BackwardInner(to);
11804   } else {
11805     ForwardInner(to);
11806   }
11807 }
11808
11809 void
11810 RevertEvent()
11811 {
11812     if (gameMode != IcsExamining) {
11813         DisplayError(_("You are not examining a game"), 0);
11814         return;
11815     }
11816     if (pausing) {
11817         DisplayError(_("You can't revert while pausing"), 0);
11818         return;
11819     }
11820     SendToICS(ics_prefix);
11821     SendToICS("revert\n");
11822 }
11823
11824 void
11825 RetractMoveEvent()
11826 {
11827     switch (gameMode) {
11828       case MachinePlaysWhite:
11829       case MachinePlaysBlack:
11830         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
11831             DisplayError(_("Wait until your turn,\nor select Move Now"), 0);
11832             return;
11833         }
11834         if (forwardMostMove < 2) return;
11835         currentMove = forwardMostMove = forwardMostMove - 2;
11836         whiteTimeRemaining = timeRemaining[0][currentMove];
11837         blackTimeRemaining = timeRemaining[1][currentMove];
11838         DisplayBothClocks();
11839         DisplayMove(currentMove - 1);
11840         ClearHighlights();/*!! could figure this out*/
11841         DrawPosition(TRUE, boards[currentMove]); /* [AS] Changed to full redraw! */
11842         SendToProgram("remove\n", &first);
11843         /*first.maybeThinking = TRUE;*/ /* GNU Chess does not ponder here */
11844         break;
11845
11846       case BeginningOfGame:
11847       default:
11848         break;
11849
11850       case IcsPlayingWhite:
11851       case IcsPlayingBlack:
11852         if (WhiteOnMove(forwardMostMove) == (gameMode == IcsPlayingWhite)) {
11853             SendToICS(ics_prefix);
11854             SendToICS("takeback 2\n");
11855         } else {
11856             SendToICS(ics_prefix);
11857             SendToICS("takeback 1\n");
11858         }
11859         break;
11860     }
11861 }
11862
11863 void
11864 MoveNowEvent()
11865 {
11866     ChessProgramState *cps;
11867
11868     switch (gameMode) {
11869       case MachinePlaysWhite:
11870         if (!WhiteOnMove(forwardMostMove)) {
11871             DisplayError(_("It is your turn"), 0);
11872             return;
11873         }
11874         cps = &first;
11875         break;
11876       case MachinePlaysBlack:
11877         if (WhiteOnMove(forwardMostMove)) {
11878             DisplayError(_("It is your turn"), 0);
11879             return;
11880         }
11881         cps = &first;
11882         break;
11883       case TwoMachinesPlay:
11884         if (WhiteOnMove(forwardMostMove) ==
11885             (first.twoMachinesColor[0] == 'w')) {
11886             cps = &first;
11887         } else {
11888             cps = &second;
11889         }
11890         break;
11891       case BeginningOfGame:
11892       default:
11893         return;
11894     }
11895     SendToProgram("?\n", cps);
11896 }
11897
11898 void
11899 TruncateGameEvent()
11900 {
11901     EditGameEvent();
11902     if (gameMode != EditGame) return;
11903     TruncateGame();
11904 }
11905
11906 void
11907 TruncateGame()
11908 {
11909     if (forwardMostMove > currentMove) {
11910         if (gameInfo.resultDetails != NULL) {
11911             free(gameInfo.resultDetails);
11912             gameInfo.resultDetails = NULL;
11913             gameInfo.result = GameUnfinished;
11914         }
11915         forwardMostMove = currentMove;
11916         HistorySet(parseList, backwardMostMove, forwardMostMove,
11917                    currentMove-1);
11918     }
11919 }
11920
11921 void
11922 HintEvent()
11923 {
11924     if (appData.noChessProgram) return;
11925     switch (gameMode) {
11926       case MachinePlaysWhite:
11927         if (WhiteOnMove(forwardMostMove)) {
11928             DisplayError(_("Wait until your turn"), 0);
11929             return;
11930         }
11931         break;
11932       case BeginningOfGame:
11933       case MachinePlaysBlack:
11934         if (!WhiteOnMove(forwardMostMove)) {
11935             DisplayError(_("Wait until your turn"), 0);
11936             return;
11937         }
11938         break;
11939       default:
11940         DisplayError(_("No hint available"), 0);
11941         return;
11942     }
11943     SendToProgram("hint\n", &first);
11944     hintRequested = TRUE;
11945 }
11946
11947 void
11948 BookEvent()
11949 {
11950     if (appData.noChessProgram) return;
11951     switch (gameMode) {
11952       case MachinePlaysWhite:
11953         if (WhiteOnMove(forwardMostMove)) {
11954             DisplayError(_("Wait until your turn"), 0);
11955             return;
11956         }
11957         break;
11958       case BeginningOfGame:
11959       case MachinePlaysBlack:
11960         if (!WhiteOnMove(forwardMostMove)) {
11961             DisplayError(_("Wait until your turn"), 0);
11962             return;
11963         }
11964         break;
11965       case EditPosition:
11966         EditPositionDone();
11967         break;
11968       case TwoMachinesPlay:
11969         return;
11970       default:
11971         break;
11972     }
11973     SendToProgram("bk\n", &first);
11974     bookOutput[0] = NULLCHAR;
11975     bookRequested = TRUE;
11976 }
11977
11978 void
11979 AboutGameEvent()
11980 {
11981     char *tags = PGNTags(&gameInfo);
11982     TagsPopUp(tags, CmailMsg());
11983     free(tags);
11984 }
11985
11986 /* end button procedures */
11987
11988 void
11989 PrintPosition(fp, move)
11990      FILE *fp;
11991      int move;
11992 {
11993     int i, j;
11994
11995     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
11996         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
11997             char c = PieceToChar(boards[move][i][j]);
11998             fputc(c == 'x' ? '.' : c, fp);
11999             fputc(j == BOARD_RGHT - 1 ? '\n' : ' ', fp);
12000         }
12001     }
12002     if ((gameMode == EditPosition) ? !blackPlaysFirst : (move % 2 == 0))
12003       fprintf(fp, "white to play\n");
12004     else
12005       fprintf(fp, "black to play\n");
12006 }
12007
12008 void
12009 PrintOpponents(fp)
12010      FILE *fp;
12011 {
12012     if (gameInfo.white != NULL) {
12013         fprintf(fp, "\t%s vs. %s\n", gameInfo.white, gameInfo.black);
12014     } else {
12015         fprintf(fp, "\n");
12016     }
12017 }
12018
12019 /* Find last component of program's own name, using some heuristics */
12020 void
12021 TidyProgramName(prog, host, buf)
12022      char *prog, *host, buf[MSG_SIZ];
12023 {
12024     char *p, *q;
12025     int local = (strcmp(host, "localhost") == 0);
12026     while (!local && (p = strchr(prog, ';')) != NULL) {
12027         p++;
12028         while (*p == ' ') p++;
12029         prog = p;
12030     }
12031     if (*prog == '"' || *prog == '\'') {
12032         q = strchr(prog + 1, *prog);
12033     } else {
12034         q = strchr(prog, ' ');
12035     }
12036     if (q == NULL) q = prog + strlen(prog);
12037     p = q;
12038     while (p >= prog && *p != '/' && *p != '\\') p--;
12039     p++;
12040     if(p == prog && *p == '"') p++;
12041     if (q - p >= 4 && StrCaseCmp(q - 4, ".exe") == 0) q -= 4;
12042     memcpy(buf, p, q - p);
12043     buf[q - p] = NULLCHAR;
12044     if (!local) {
12045         strcat(buf, "@");
12046         strcat(buf, host);
12047     }
12048 }
12049
12050 char *
12051 TimeControlTagValue()
12052 {
12053     char buf[MSG_SIZ];
12054     if (!appData.clockMode) {
12055         strcpy(buf, "-");
12056     } else if (movesPerSession > 0) {
12057         sprintf(buf, "%d/%ld", movesPerSession, timeControl/1000);
12058     } else if (timeIncrement == 0) {
12059         sprintf(buf, "%ld", timeControl/1000);
12060     } else {
12061         sprintf(buf, "%ld+%ld", timeControl/1000, timeIncrement/1000);
12062     }
12063     return StrSave(buf);
12064 }
12065
12066 void
12067 SetGameInfo()
12068 {
12069     /* This routine is used only for certain modes */
12070     VariantClass v = gameInfo.variant;
12071     ClearGameInfo(&gameInfo);
12072     gameInfo.variant = v;
12073
12074     switch (gameMode) {
12075       case MachinePlaysWhite:
12076         gameInfo.event = StrSave( appData.pgnEventHeader );
12077         gameInfo.site = StrSave(HostName());
12078         gameInfo.date = PGNDate();
12079         gameInfo.round = StrSave("-");
12080         gameInfo.white = StrSave(first.tidy);
12081         gameInfo.black = StrSave(UserName());
12082         gameInfo.timeControl = TimeControlTagValue();
12083         break;
12084
12085       case MachinePlaysBlack:
12086         gameInfo.event = StrSave( appData.pgnEventHeader );
12087         gameInfo.site = StrSave(HostName());
12088         gameInfo.date = PGNDate();
12089         gameInfo.round = StrSave("-");
12090         gameInfo.white = StrSave(UserName());
12091         gameInfo.black = StrSave(first.tidy);
12092         gameInfo.timeControl = TimeControlTagValue();
12093         break;
12094
12095       case TwoMachinesPlay:
12096         gameInfo.event = StrSave( appData.pgnEventHeader );
12097         gameInfo.site = StrSave(HostName());
12098         gameInfo.date = PGNDate();
12099         if (matchGame > 0) {
12100             char buf[MSG_SIZ];
12101             sprintf(buf, "%d", matchGame);
12102             gameInfo.round = StrSave(buf);
12103         } else {
12104             gameInfo.round = StrSave("-");
12105         }
12106         if (first.twoMachinesColor[0] == 'w') {
12107             gameInfo.white = StrSave(first.tidy);
12108             gameInfo.black = StrSave(second.tidy);
12109         } else {
12110             gameInfo.white = StrSave(second.tidy);
12111             gameInfo.black = StrSave(first.tidy);
12112         }
12113         gameInfo.timeControl = TimeControlTagValue();
12114         break;
12115
12116       case EditGame:
12117         gameInfo.event = StrSave("Edited game");
12118         gameInfo.site = StrSave(HostName());
12119         gameInfo.date = PGNDate();
12120         gameInfo.round = StrSave("-");
12121         gameInfo.white = StrSave("-");
12122         gameInfo.black = StrSave("-");
12123         break;
12124
12125       case EditPosition:
12126         gameInfo.event = StrSave("Edited position");
12127         gameInfo.site = StrSave(HostName());
12128         gameInfo.date = PGNDate();
12129         gameInfo.round = StrSave("-");
12130         gameInfo.white = StrSave("-");
12131         gameInfo.black = StrSave("-");
12132         break;
12133
12134       case IcsPlayingWhite:
12135       case IcsPlayingBlack:
12136       case IcsObserving:
12137       case IcsExamining:
12138         break;
12139
12140       case PlayFromGameFile:
12141         gameInfo.event = StrSave("Game from non-PGN file");
12142         gameInfo.site = StrSave(HostName());
12143         gameInfo.date = PGNDate();
12144         gameInfo.round = StrSave("-");
12145         gameInfo.white = StrSave("?");
12146         gameInfo.black = StrSave("?");
12147         break;
12148
12149       default:
12150         break;
12151     }
12152 }
12153
12154 void
12155 ReplaceComment(index, text)
12156      int index;
12157      char *text;
12158 {
12159     int len;
12160
12161     while (*text == '\n') text++;
12162     len = strlen(text);
12163     while (len > 0 && text[len - 1] == '\n') len--;
12164
12165     if (commentList[index] != NULL)
12166       free(commentList[index]);
12167
12168     if (len == 0) {
12169         commentList[index] = NULL;
12170         return;
12171     }
12172     commentList[index] = (char *) malloc(len + 2);
12173     strncpy(commentList[index], text, len);
12174     commentList[index][len] = '\n';
12175     commentList[index][len + 1] = NULLCHAR;
12176 }
12177
12178 void
12179 CrushCRs(text)
12180      char *text;
12181 {
12182   char *p = text;
12183   char *q = text;
12184   char ch;
12185
12186   do {
12187     ch = *p++;
12188     if (ch == '\r') continue;
12189     *q++ = ch;
12190   } while (ch != '\0');
12191 }
12192
12193 void
12194 AppendComment(index, text)
12195      int index;
12196      char *text;
12197 {
12198     int oldlen, len;
12199     char *old;
12200
12201     text = GetInfoFromComment( index, text ); /* [HGM] PV time: strip PV info from comment */
12202
12203     CrushCRs(text);
12204     while (*text == '\n') text++;
12205     len = strlen(text);
12206     while (len > 0 && text[len - 1] == '\n') len--;
12207
12208     if (len == 0) return;
12209
12210     if (commentList[index] != NULL) {
12211         old = commentList[index];
12212         oldlen = strlen(old);
12213         commentList[index] = (char *) malloc(oldlen + len + 2);
12214         strcpy(commentList[index], old);
12215         free(old);
12216         strncpy(&commentList[index][oldlen], text, len);
12217         commentList[index][oldlen + len] = '\n';
12218         commentList[index][oldlen + len + 1] = NULLCHAR;
12219     } else {
12220         commentList[index] = (char *) malloc(len + 2);
12221         strncpy(commentList[index], text, len);
12222         commentList[index][len] = '\n';
12223         commentList[index][len + 1] = NULLCHAR;
12224     }
12225 }
12226
12227 static char * FindStr( char * text, char * sub_text )
12228 {
12229     char * result = strstr( text, sub_text );
12230
12231     if( result != NULL ) {
12232         result += strlen( sub_text );
12233     }
12234
12235     return result;
12236 }
12237
12238 /* [AS] Try to extract PV info from PGN comment */
12239 /* [HGM] PV time: and then remove it, to prevent it appearing twice */
12240 char *GetInfoFromComment( int index, char * text )
12241 {
12242     char * sep = text;
12243
12244     if( text != NULL && index > 0 ) {
12245         int score = 0;
12246         int depth = 0;
12247         int time = -1, sec = 0, deci;
12248         char * s_eval = FindStr( text, "[%eval " );
12249         char * s_emt = FindStr( text, "[%emt " );
12250
12251         if( s_eval != NULL || s_emt != NULL ) {
12252             /* New style */
12253             char delim;
12254
12255             if( s_eval != NULL ) {
12256                 if( sscanf( s_eval, "%d,%d%c", &score, &depth, &delim ) != 3 ) {
12257                     return text;
12258                 }
12259
12260                 if( delim != ']' ) {
12261                     return text;
12262                 }
12263             }
12264
12265             if( s_emt != NULL ) {
12266             }
12267         }
12268         else {
12269             /* We expect something like: [+|-]nnn.nn/dd */
12270             int score_lo = 0;
12271
12272             sep = strchr( text, '/' );
12273             if( sep == NULL || sep < (text+4) ) {
12274                 return text;
12275             }
12276
12277             time = -1; sec = -1; deci = -1;
12278             if( sscanf( text, "%d.%d/%d %d:%d", &score, &score_lo, &depth, &time, &sec ) != 5 &&
12279                 sscanf( text, "%d.%d/%d %d.%d", &score, &score_lo, &depth, &time, &deci ) != 5 &&
12280                 sscanf( text, "%d.%d/%d %d", &score, &score_lo, &depth, &time ) != 4 &&
12281                 sscanf( text, "%d.%d/%d", &score, &score_lo, &depth ) != 3   ) {
12282                 return text;
12283             }
12284
12285             if( score_lo < 0 || score_lo >= 100 ) {
12286                 return text;
12287             }
12288
12289             if(sec >= 0) time = 600*time + 10*sec; else
12290             if(deci >= 0) time = 10*time + deci; else time *= 10; // deci-sec
12291
12292             score = score >= 0 ? score*100 + score_lo : score*100 - score_lo;
12293
12294             /* [HGM] PV time: now locate end of PV info */
12295             while( *++sep >= '0' && *sep <= '9'); // strip depth
12296             if(time >= 0)
12297             while( *++sep >= '0' && *sep <= '9'); // strip time
12298             if(sec >= 0)
12299             while( *++sep >= '0' && *sep <= '9'); // strip seconds
12300             if(deci >= 0)
12301             while( *++sep >= '0' && *sep <= '9'); // strip fractional seconds
12302             while(*sep == ' ') sep++;
12303         }
12304
12305         if( depth <= 0 ) {
12306             return text;
12307         }
12308
12309         if( time < 0 ) {
12310             time = -1;
12311         }
12312
12313         pvInfoList[index-1].depth = depth;
12314         pvInfoList[index-1].score = score;
12315         pvInfoList[index-1].time  = 10*time; // centi-sec
12316     }
12317     return sep;
12318 }
12319
12320 void
12321 SendToProgram(message, cps)
12322      char *message;
12323      ChessProgramState *cps;
12324 {
12325     int count, outCount, error;
12326     char buf[MSG_SIZ];
12327
12328     if (cps->pr == NULL) return;
12329     Attention(cps);
12330
12331     if (appData.debugMode) {
12332         TimeMark now;
12333         GetTimeMark(&now);
12334         fprintf(debugFP, "%ld >%-6s: %s",
12335                 SubtractTimeMarks(&now, &programStartTime),
12336                 cps->which, message);
12337     }
12338
12339     count = strlen(message);
12340     outCount = OutputToProcess(cps->pr, message, count, &error);
12341     if (outCount < count && !exiting
12342                          && !endingGame) { /* [HGM] crash: to not hang GameEnds() writing to deceased engines */
12343         sprintf(buf, _("Error writing to %s chess program"), cps->which);
12344         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
12345             if(epStatus[forwardMostMove] <= EP_DRAWS) {
12346                 gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
12347                 sprintf(buf, "%s program exits in draw position (%s)", cps->which, cps->program);
12348             } else {
12349                 gameInfo.result = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
12350             }
12351             gameInfo.resultDetails = buf;
12352         }
12353         DisplayFatalError(buf, error, 1);
12354     }
12355 }
12356
12357 void
12358 ReceiveFromProgram(isr, closure, message, count, error)
12359      InputSourceRef isr;
12360      VOIDSTAR closure;
12361      char *message;
12362      int count;
12363      int error;
12364 {
12365     char *end_str;
12366     char buf[MSG_SIZ];
12367     ChessProgramState *cps = (ChessProgramState *)closure;
12368
12369     if (isr != cps->isr) return; /* Killed intentionally */
12370     if (count <= 0) {
12371         if (count == 0) {
12372             sprintf(buf,
12373                     _("Error: %s chess program (%s) exited unexpectedly"),
12374                     cps->which, cps->program);
12375         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
12376                 if(epStatus[forwardMostMove] <= EP_DRAWS) {
12377                     gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
12378                     sprintf(buf, _("%s program exits in draw position (%s)"), cps->which, cps->program);
12379                 } else {
12380                     gameInfo.result = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
12381                 }
12382                 gameInfo.resultDetails = buf;
12383             }
12384             RemoveInputSource(cps->isr);
12385             DisplayFatalError(buf, 0, 1);
12386         } else {
12387             sprintf(buf,
12388                     _("Error reading from %s chess program (%s)"),
12389                     cps->which, cps->program);
12390             RemoveInputSource(cps->isr);
12391
12392             /* [AS] Program is misbehaving badly... kill it */
12393             if( count == -2 ) {
12394                 DestroyChildProcess( cps->pr, 9 );
12395                 cps->pr = NoProc;
12396             }
12397
12398             DisplayFatalError(buf, error, 1);
12399         }
12400         return;
12401     }
12402
12403     if ((end_str = strchr(message, '\r')) != NULL)
12404       *end_str = NULLCHAR;
12405     if ((end_str = strchr(message, '\n')) != NULL)
12406       *end_str = NULLCHAR;
12407
12408     if (appData.debugMode) {
12409         TimeMark now; int print = 1;
12410         char *quote = ""; char c; int i;
12411
12412         if(appData.engineComments != 1) { /* [HGM] debug: decide if protocol-violating output is written */
12413                 char start = message[0];
12414                 if(start >='A' && start <= 'Z') start += 'a' - 'A'; // be tolerant to capitalizing
12415                 if(sscanf(message, "%d%c%d%d%d", &i, &c, &i, &i, &i) != 5 &&
12416                    sscanf(message, "move %c", &c)!=1  && sscanf(message, "offer%c", &c)!=1 &&
12417                    sscanf(message, "resign%c", &c)!=1 && sscanf(message, "feature %c", &c)!=1 &&
12418                    sscanf(message, "error %c", &c)!=1 && sscanf(message, "illegal %c", &c)!=1 &&
12419                    sscanf(message, "tell%c", &c)!=1   && sscanf(message, "0-1 %c", &c)!=1 &&
12420                    sscanf(message, "1-0 %c", &c)!=1   && sscanf(message, "1/2-1/2 %c", &c)!=1 &&
12421                    sscanf(message, "pong %c", &c)!=1   && start != '#')
12422                         { quote = "# "; print = (appData.engineComments == 2); }
12423                 message[0] = start; // restore original message
12424         }
12425         if(print) {
12426                 GetTimeMark(&now);
12427                 fprintf(debugFP, "%ld <%-6s: %s%s\n",
12428                         SubtractTimeMarks(&now, &programStartTime), cps->which,
12429                         quote,
12430                         message);
12431         }
12432     }
12433
12434     /* [DM] if icsEngineAnalyze is active we block all whisper and kibitz output, because nobody want to see this */
12435     if (appData.icsEngineAnalyze) {
12436         if (strstr(message, "whisper") != NULL ||
12437              strstr(message, "kibitz") != NULL ||
12438             strstr(message, "tellics") != NULL) return;
12439     }
12440
12441     HandleMachineMove(message, cps);
12442 }
12443
12444
12445 void
12446 SendTimeControl(cps, mps, tc, inc, sd, st)
12447      ChessProgramState *cps;
12448      int mps, inc, sd, st;
12449      long tc;
12450 {
12451     char buf[MSG_SIZ];
12452     int seconds;
12453
12454     if( timeControl_2 > 0 ) {
12455         if( (gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b') ) {
12456             tc = timeControl_2;
12457         }
12458     }
12459     tc  /= cps->timeOdds; /* [HGM] time odds: apply before telling engine */
12460     inc /= cps->timeOdds;
12461     st  /= cps->timeOdds;
12462
12463     seconds = (tc / 1000) % 60; /* [HGM] displaced to after applying odds */
12464
12465     if (st > 0) {
12466       /* Set exact time per move, normally using st command */
12467       if (cps->stKludge) {
12468         /* GNU Chess 4 has no st command; uses level in a nonstandard way */
12469         seconds = st % 60;
12470         if (seconds == 0) {
12471           sprintf(buf, "level 1 %d\n", st/60);
12472         } else {
12473           sprintf(buf, "level 1 %d:%02d\n", st/60, seconds);
12474         }
12475       } else {
12476         sprintf(buf, "st %d\n", st);
12477       }
12478     } else {
12479       /* Set conventional or incremental time control, using level command */
12480       if (seconds == 0) {
12481         /* Note old gnuchess bug -- minutes:seconds used to not work.
12482            Fixed in later versions, but still avoid :seconds
12483            when seconds is 0. */
12484         sprintf(buf, "level %d %ld %d\n", mps, tc/60000, inc/1000);
12485       } else {
12486         sprintf(buf, "level %d %ld:%02d %d\n", mps, tc/60000,
12487                 seconds, inc/1000);
12488       }
12489     }
12490     SendToProgram(buf, cps);
12491
12492     /* Orthoganally (except for GNU Chess 4), limit time to st seconds */
12493     /* Orthogonally, limit search to given depth */
12494     if (sd > 0) {
12495       if (cps->sdKludge) {
12496         sprintf(buf, "depth\n%d\n", sd);
12497       } else {
12498         sprintf(buf, "sd %d\n", sd);
12499       }
12500       SendToProgram(buf, cps);
12501     }
12502
12503     if(cps->nps > 0) { /* [HGM] nps */
12504         if(cps->supportsNPS == FALSE) cps->nps = -1; // don't use if engine explicitly says not supported!
12505         else {
12506                 sprintf(buf, "nps %d\n", cps->nps);
12507               SendToProgram(buf, cps);
12508         }
12509     }
12510 }
12511
12512 ChessProgramState *WhitePlayer()
12513 /* [HGM] return pointer to 'first' or 'second', depending on who plays white */
12514 {
12515     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b' ||
12516        gameMode == BeginningOfGame || gameMode == MachinePlaysBlack)
12517         return &second;
12518     return &first;
12519 }
12520
12521 void
12522 SendTimeRemaining(cps, machineWhite)
12523      ChessProgramState *cps;
12524      int /*boolean*/ machineWhite;
12525 {
12526     char message[MSG_SIZ];
12527     long time, otime;
12528
12529     /* Note: this routine must be called when the clocks are stopped
12530        or when they have *just* been set or switched; otherwise
12531        it will be off by the time since the current tick started.
12532     */
12533     if (machineWhite) {
12534         time = whiteTimeRemaining / 10;
12535         otime = blackTimeRemaining / 10;
12536     } else {
12537         time = blackTimeRemaining / 10;
12538         otime = whiteTimeRemaining / 10;
12539     }
12540     /* [HGM] translate opponent's time by time-odds factor */
12541     otime = (otime * cps->other->timeOdds) / cps->timeOdds;
12542     if (appData.debugMode) {
12543         fprintf(debugFP, "time odds: %d %d \n", cps->timeOdds, cps->other->timeOdds);
12544     }
12545
12546     if (time <= 0) time = 1;
12547     if (otime <= 0) otime = 1;
12548
12549     sprintf(message, "time %ld\n", time);
12550     SendToProgram(message, cps);
12551
12552     sprintf(message, "otim %ld\n", otime);
12553     SendToProgram(message, cps);
12554 }
12555
12556 int
12557 BoolFeature(p, name, loc, cps)
12558      char **p;
12559      char *name;
12560      int *loc;
12561      ChessProgramState *cps;
12562 {
12563   char buf[MSG_SIZ];
12564   int len = strlen(name);
12565   int val;
12566   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
12567     (*p) += len + 1;
12568     sscanf(*p, "%d", &val);
12569     *loc = (val != 0);
12570     while (**p && **p != ' ') (*p)++;
12571     sprintf(buf, "accepted %s\n", name);
12572     SendToProgram(buf, cps);
12573     return TRUE;
12574   }
12575   return FALSE;
12576 }
12577
12578 int
12579 IntFeature(p, name, loc, cps)
12580      char **p;
12581      char *name;
12582      int *loc;
12583      ChessProgramState *cps;
12584 {
12585   char buf[MSG_SIZ];
12586   int len = strlen(name);
12587   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
12588     (*p) += len + 1;
12589     sscanf(*p, "%d", loc);
12590     while (**p && **p != ' ') (*p)++;
12591     sprintf(buf, "accepted %s\n", name);
12592     SendToProgram(buf, cps);
12593     return TRUE;
12594   }
12595   return FALSE;
12596 }
12597
12598 int
12599 StringFeature(p, name, loc, cps)
12600      char **p;
12601      char *name;
12602      char loc[];
12603      ChessProgramState *cps;
12604 {
12605   char buf[MSG_SIZ];
12606   int len = strlen(name);
12607   if (strncmp((*p), name, len) == 0
12608       && (*p)[len] == '=' && (*p)[len+1] == '\"') {
12609     (*p) += len + 2;
12610     sscanf(*p, "%[^\"]", loc);
12611     while (**p && **p != '\"') (*p)++;
12612     if (**p == '\"') (*p)++;
12613     sprintf(buf, "accepted %s\n", name);
12614     SendToProgram(buf, cps);
12615     return TRUE;
12616   }
12617   return FALSE;
12618 }
12619
12620 int
12621 ParseOption(Option *opt, ChessProgramState *cps)
12622 // [HGM] options: process the string that defines an engine option, and determine
12623 // name, type, default value, and allowed value range
12624 {
12625         char *p, *q, buf[MSG_SIZ];
12626         int n, min = (-1)<<31, max = 1<<31, def;
12627
12628         if(p = strstr(opt->name, " -spin ")) {
12629             if((n = sscanf(p, " -spin %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
12630             if(max < min) max = min; // enforce consistency
12631             if(def < min) def = min;
12632             if(def > max) def = max;
12633             opt->value = def;
12634             opt->min = min;
12635             opt->max = max;
12636             opt->type = Spin;
12637         } else if((p = strstr(opt->name, " -slider "))) {
12638             // for now -slider is a synonym for -spin, to already provide compatibility with future polyglots
12639             if((n = sscanf(p, " -slider %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
12640             if(max < min) max = min; // enforce consistency
12641             if(def < min) def = min;
12642             if(def > max) def = max;
12643             opt->value = def;
12644             opt->min = min;
12645             opt->max = max;
12646             opt->type = Spin; // Slider;
12647         } else if((p = strstr(opt->name, " -string "))) {
12648             opt->textValue = p+9;
12649             opt->type = TextBox;
12650         } else if((p = strstr(opt->name, " -file "))) {
12651             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
12652             opt->textValue = p+7;
12653             opt->type = TextBox; // FileName;
12654         } else if((p = strstr(opt->name, " -path "))) {
12655             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
12656             opt->textValue = p+7;
12657             opt->type = TextBox; // PathName;
12658         } else if(p = strstr(opt->name, " -check ")) {
12659             if(sscanf(p, " -check %d", &def) < 1) return FALSE;
12660             opt->value = (def != 0);
12661             opt->type = CheckBox;
12662         } else if(p = strstr(opt->name, " -combo ")) {
12663             opt->textValue = (char*) (&cps->comboList[cps->comboCnt]); // cheat with pointer type
12664             cps->comboList[cps->comboCnt++] = q = p+8; // holds possible choices
12665             if(*q == '*') cps->comboList[cps->comboCnt-1]++;
12666             opt->value = n = 0;
12667             while(q = StrStr(q, " /// ")) {
12668                 n++; *q = 0;    // count choices, and null-terminate each of them
12669                 q += 5;
12670                 if(*q == '*') { // remember default, which is marked with * prefix
12671                     q++;
12672                     opt->value = n;
12673                 }
12674                 cps->comboList[cps->comboCnt++] = q;
12675             }
12676             cps->comboList[cps->comboCnt++] = NULL;
12677             opt->max = n + 1;
12678             opt->type = ComboBox;
12679         } else if(p = strstr(opt->name, " -button")) {
12680             opt->type = Button;
12681         } else if(p = strstr(opt->name, " -save")) {
12682             opt->type = SaveButton;
12683         } else return FALSE;
12684         *p = 0; // terminate option name
12685         // now look if the command-line options define a setting for this engine option.
12686         if(cps->optionSettings && cps->optionSettings[0])
12687             p = strstr(cps->optionSettings, opt->name); else p = NULL;
12688         if(p && (p == cps->optionSettings || p[-1] == ',')) {
12689                 sprintf(buf, "option %s", p);
12690                 if(p = strstr(buf, ",")) *p = 0;
12691                 strcat(buf, "\n");
12692                 SendToProgram(buf, cps);
12693         }
12694         return TRUE;
12695 }
12696
12697 void
12698 FeatureDone(cps, val)
12699      ChessProgramState* cps;
12700      int val;
12701 {
12702   DelayedEventCallback cb = GetDelayedEvent();
12703   if ((cb == InitBackEnd3 && cps == &first) ||
12704       (cb == TwoMachinesEventIfReady && cps == &second)) {
12705     CancelDelayedEvent();
12706     ScheduleDelayedEvent(cb, val ? 1 : 3600000);
12707   }
12708   cps->initDone = val;
12709 }
12710
12711 /* Parse feature command from engine */
12712 void
12713 ParseFeatures(args, cps)
12714      char* args;
12715      ChessProgramState *cps;
12716 {
12717   char *p = args;
12718   char *q;
12719   int val;
12720   char buf[MSG_SIZ];
12721
12722   for (;;) {
12723     while (*p == ' ') p++;
12724     if (*p == NULLCHAR) return;
12725
12726     if (BoolFeature(&p, "setboard", &cps->useSetboard, cps)) continue;
12727     if (BoolFeature(&p, "time", &cps->sendTime, cps)) continue;
12728     if (BoolFeature(&p, "draw", &cps->sendDrawOffers, cps)) continue;
12729     if (BoolFeature(&p, "sigint", &cps->useSigint, cps)) continue;
12730     if (BoolFeature(&p, "sigterm", &cps->useSigterm, cps)) continue;
12731     if (BoolFeature(&p, "reuse", &val, cps)) {
12732       /* Engine can disable reuse, but can't enable it if user said no */
12733       if (!val) cps->reuse = FALSE;
12734       continue;
12735     }
12736     if (BoolFeature(&p, "analyze", &cps->analysisSupport, cps)) continue;
12737     if (StringFeature(&p, "myname", &cps->tidy, cps)) {
12738       if (gameMode == TwoMachinesPlay) {
12739         DisplayTwoMachinesTitle();
12740       } else {
12741         DisplayTitle("");
12742       }
12743       continue;
12744     }
12745     if (StringFeature(&p, "variants", &cps->variants, cps)) continue;
12746     if (BoolFeature(&p, "san", &cps->useSAN, cps)) continue;
12747     if (BoolFeature(&p, "ping", &cps->usePing, cps)) continue;
12748     if (BoolFeature(&p, "playother", &cps->usePlayother, cps)) continue;
12749     if (BoolFeature(&p, "colors", &cps->useColors, cps)) continue;
12750     if (BoolFeature(&p, "usermove", &cps->useUsermove, cps)) continue;
12751     if (BoolFeature(&p, "ics", &cps->sendICS, cps)) continue;
12752     if (BoolFeature(&p, "name", &cps->sendName, cps)) continue;
12753     if (BoolFeature(&p, "pause", &val, cps)) continue; /* unused at present */
12754     if (IntFeature(&p, "done", &val, cps)) {
12755       FeatureDone(cps, val);
12756       continue;
12757     }
12758     /* Added by Tord: */
12759     if (BoolFeature(&p, "fen960", &cps->useFEN960, cps)) continue;
12760     if (BoolFeature(&p, "oocastle", &cps->useOOCastle, cps)) continue;
12761     /* End of additions by Tord */
12762
12763     /* [HGM] added features: */
12764     if (BoolFeature(&p, "debug", &cps->debug, cps)) continue;
12765     if (BoolFeature(&p, "nps", &cps->supportsNPS, cps)) continue;
12766     if (IntFeature(&p, "level", &cps->maxNrOfSessions, cps)) continue;
12767     if (BoolFeature(&p, "memory", &cps->memSize, cps)) continue;
12768     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
12769     if (StringFeature(&p, "egt", &cps->egtFormats, cps)) continue;
12770     if (StringFeature(&p, "option", &(cps->option[cps->nrOptions].name), cps)) {
12771         if(!ParseOption(&(cps->option[cps->nrOptions++]), cps)) { // [HGM] options: add option feature
12772             sprintf(buf, "rejected option %s\n", cps->option[--cps->nrOptions].name);
12773             SendToProgram(buf, cps);
12774             continue;
12775         }
12776         if(cps->nrOptions >= MAX_OPTIONS) {
12777             cps->nrOptions--;
12778             sprintf(buf, "%s engine has too many options\n", cps->which);
12779             DisplayError(buf, 0);
12780         }
12781         continue;
12782     }
12783     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
12784     /* End of additions by HGM */
12785
12786     /* unknown feature: complain and skip */
12787     q = p;
12788     while (*q && *q != '=') q++;
12789     sprintf(buf, "rejected %.*s\n", q-p, p);
12790     SendToProgram(buf, cps);
12791     p = q;
12792     if (*p == '=') {
12793       p++;
12794       if (*p == '\"') {
12795         p++;
12796         while (*p && *p != '\"') p++;
12797         if (*p == '\"') p++;
12798       } else {
12799         while (*p && *p != ' ') p++;
12800       }
12801     }
12802   }
12803
12804 }
12805
12806 void
12807 PeriodicUpdatesEvent(newState)
12808      int newState;
12809 {
12810     if (newState == appData.periodicUpdates)
12811       return;
12812
12813     appData.periodicUpdates=newState;
12814
12815     /* Display type changes, so update it now */
12816 //    DisplayAnalysis();
12817
12818     /* Get the ball rolling again... */
12819     if (newState) {
12820         AnalysisPeriodicEvent(1);
12821         StartAnalysisClock();
12822     }
12823 }
12824
12825 void
12826 PonderNextMoveEvent(newState)
12827      int newState;
12828 {
12829     if (newState == appData.ponderNextMove) return;
12830     if (gameMode == EditPosition) EditPositionDone();
12831     if (newState) {
12832         SendToProgram("hard\n", &first);
12833         if (gameMode == TwoMachinesPlay) {
12834             SendToProgram("hard\n", &second);
12835         }
12836     } else {
12837         SendToProgram("easy\n", &first);
12838         thinkOutput[0] = NULLCHAR;
12839         if (gameMode == TwoMachinesPlay) {
12840             SendToProgram("easy\n", &second);
12841         }
12842     }
12843     appData.ponderNextMove = newState;
12844 }
12845
12846 void
12847 NewSettingEvent(option, command, value)
12848      char *command;
12849      int option, value;
12850 {
12851     char buf[MSG_SIZ];
12852
12853     if (gameMode == EditPosition) EditPositionDone();
12854     sprintf(buf, "%s%s %d\n", (option ? "option ": ""), command, value);
12855     SendToProgram(buf, &first);
12856     if (gameMode == TwoMachinesPlay) {
12857         SendToProgram(buf, &second);
12858     }
12859 }
12860
12861 void
12862 ShowThinkingEvent()
12863 // [HGM] thinking: this routine is now also called from "Options -> Engine..." popup
12864 {
12865     static int oldState = 2; // kludge alert! Neither true nor fals, so first time oldState is always updated
12866     int newState = appData.showThinking
12867         // [HGM] thinking: other features now need thinking output as well
12868         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp();
12869
12870     if (oldState == newState) return;
12871     oldState = newState;
12872     if (gameMode == EditPosition) EditPositionDone();
12873     if (oldState) {
12874         SendToProgram("post\n", &first);
12875         if (gameMode == TwoMachinesPlay) {
12876             SendToProgram("post\n", &second);
12877         }
12878     } else {
12879         SendToProgram("nopost\n", &first);
12880         thinkOutput[0] = NULLCHAR;
12881         if (gameMode == TwoMachinesPlay) {
12882             SendToProgram("nopost\n", &second);
12883         }
12884     }
12885 //    appData.showThinking = newState; // [HGM] thinking: responsible option should already have be changed when calling this routine!
12886 }
12887
12888 void
12889 AskQuestionEvent(title, question, replyPrefix, which)
12890      char *title; char *question; char *replyPrefix; char *which;
12891 {
12892   ProcRef pr = (which[0] == '1') ? first.pr : second.pr;
12893   if (pr == NoProc) return;
12894   AskQuestion(title, question, replyPrefix, pr);
12895 }
12896
12897 void
12898 DisplayMove(moveNumber)
12899      int moveNumber;
12900 {
12901     char message[MSG_SIZ];
12902     char res[MSG_SIZ];
12903     char cpThinkOutput[MSG_SIZ];
12904
12905     if(appData.noGUI) return; // [HGM] fast: suppress display of moves
12906
12907     if (moveNumber == forwardMostMove - 1 ||
12908         gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12909
12910         safeStrCpy(cpThinkOutput, thinkOutput, sizeof(cpThinkOutput));
12911
12912         if (strchr(cpThinkOutput, '\n')) {
12913             *strchr(cpThinkOutput, '\n') = NULLCHAR;
12914         }
12915     } else {
12916         *cpThinkOutput = NULLCHAR;
12917     }
12918
12919     /* [AS] Hide thinking from human user */
12920     if( appData.hideThinkingFromHuman && gameMode != TwoMachinesPlay ) {
12921         *cpThinkOutput = NULLCHAR;
12922         if( thinkOutput[0] != NULLCHAR ) {
12923             int i;
12924
12925             for( i=0; i<=hiddenThinkOutputState; i++ ) {
12926                 cpThinkOutput[i] = '.';
12927             }
12928             cpThinkOutput[i] = NULLCHAR;
12929             hiddenThinkOutputState = (hiddenThinkOutputState + 1) % 3;
12930         }
12931     }
12932
12933     if (moveNumber == forwardMostMove - 1 &&
12934         gameInfo.resultDetails != NULL) {
12935         if (gameInfo.resultDetails[0] == NULLCHAR) {
12936             sprintf(res, " %s", PGNResult(gameInfo.result));
12937         } else {
12938             sprintf(res, " {%s} %s",
12939                     gameInfo.resultDetails, PGNResult(gameInfo.result));
12940         }
12941     } else {
12942         res[0] = NULLCHAR;
12943     }
12944
12945     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
12946         DisplayMessage(res, cpThinkOutput);
12947     } else {
12948         sprintf(message, "%d.%s%s%s", moveNumber / 2 + 1,
12949                 WhiteOnMove(moveNumber) ? " " : ".. ",
12950                 parseList[moveNumber], res);
12951         DisplayMessage(message, cpThinkOutput);
12952     }
12953 }
12954
12955 void
12956 DisplayComment(moveNumber, text)
12957      int moveNumber;
12958      char *text;
12959 {
12960     char title[MSG_SIZ];
12961     char buf[8000]; // comment can be long!
12962     int score, depth;
12963
12964     if( appData.autoDisplayComment ) {
12965         if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
12966             strcpy(title, "Comment");
12967         } else {
12968             sprintf(title, "Comment on %d.%s%s", moveNumber / 2 + 1,
12969                     WhiteOnMove(moveNumber) ? " " : ".. ",
12970                     parseList[moveNumber]);
12971         }
12972         // [HGM] PV info: display PV info together with (or as) comment
12973         if(moveNumber >= 0 && (depth = pvInfoList[moveNumber].depth) > 0) {
12974             if(text == NULL) text = "";
12975             score = pvInfoList[moveNumber].score;
12976             sprintf(buf, "%s%.2f/%d %d\n%s", score>0 ? "+" : "", score/100.,
12977                               depth, (pvInfoList[moveNumber].time+50)/100, text);
12978             text = buf;
12979         }
12980     } else title[0] = 0;
12981
12982     if (text != NULL)
12983         CommentPopUp(title, text);
12984 }
12985
12986 /* This routine sends a ^C interrupt to gnuchess, to awaken it if it
12987  * might be busy thinking or pondering.  It can be omitted if your
12988  * gnuchess is configured to stop thinking immediately on any user
12989  * input.  However, that gnuchess feature depends on the FIONREAD
12990  * ioctl, which does not work properly on some flavors of Unix.
12991  */
12992 void
12993 Attention(cps)
12994      ChessProgramState *cps;
12995 {
12996 #if ATTENTION
12997     if (!cps->useSigint) return;
12998     if (appData.noChessProgram || (cps->pr == NoProc)) return;
12999     switch (gameMode) {
13000       case MachinePlaysWhite:
13001       case MachinePlaysBlack:
13002       case TwoMachinesPlay:
13003       case IcsPlayingWhite:
13004       case IcsPlayingBlack:
13005       case AnalyzeMode:
13006       case AnalyzeFile:
13007         /* Skip if we know it isn't thinking */
13008         if (!cps->maybeThinking) return;
13009         if (appData.debugMode)
13010           fprintf(debugFP, "Interrupting %s\n", cps->which);
13011         InterruptChildProcess(cps->pr);
13012         cps->maybeThinking = FALSE;
13013         break;
13014       default:
13015         break;
13016     }
13017 #endif /*ATTENTION*/
13018 }
13019
13020 int
13021 CheckFlags()
13022 {
13023     if (whiteTimeRemaining <= 0) {
13024         if (!whiteFlag) {
13025             whiteFlag = TRUE;
13026             if (appData.icsActive) {
13027                 if (appData.autoCallFlag &&
13028                     gameMode == IcsPlayingBlack && !blackFlag) {
13029                   SendToICS(ics_prefix);
13030                   SendToICS("flag\n");
13031                 }
13032             } else {
13033                 if (blackFlag) {
13034                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
13035                 } else {
13036                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("White's flag fell"));
13037                     if (appData.autoCallFlag) {
13038                         GameEnds(BlackWins, "Black wins on time", GE_XBOARD);
13039                         return TRUE;
13040                     }
13041                 }
13042             }
13043         }
13044     }
13045     if (blackTimeRemaining <= 0) {
13046         if (!blackFlag) {
13047             blackFlag = TRUE;
13048             if (appData.icsActive) {
13049                 if (appData.autoCallFlag &&
13050                     gameMode == IcsPlayingWhite && !whiteFlag) {
13051                   SendToICS(ics_prefix);
13052                   SendToICS("flag\n");
13053                 }
13054             } else {
13055                 if (whiteFlag) {
13056                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
13057                 } else {
13058                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Black's flag fell"));
13059                     if (appData.autoCallFlag) {
13060                         GameEnds(WhiteWins, "White wins on time", GE_XBOARD);
13061                         return TRUE;
13062                     }
13063                 }
13064             }
13065         }
13066     }
13067     return FALSE;
13068 }
13069
13070 void
13071 CheckTimeControl()
13072 {
13073     if (!appData.clockMode || appData.icsActive ||
13074         gameMode == PlayFromGameFile || forwardMostMove == 0) return;
13075
13076     /*
13077      * add time to clocks when time control is achieved ([HGM] now also used for increment)
13078      */
13079     if ( !WhiteOnMove(forwardMostMove) )
13080         /* White made time control */
13081         whiteTimeRemaining += GetTimeQuota((forwardMostMove-1)/2)
13082         /* [HGM] time odds: correct new time quota for time odds! */
13083                                             / WhitePlayer()->timeOdds;
13084       else
13085         /* Black made time control */
13086         blackTimeRemaining += GetTimeQuota((forwardMostMove-1)/2)
13087                                             / WhitePlayer()->other->timeOdds;
13088 }
13089
13090 void
13091 DisplayBothClocks()
13092 {
13093     int wom = gameMode == EditPosition ?
13094       !blackPlaysFirst : WhiteOnMove(currentMove);
13095     DisplayWhiteClock(whiteTimeRemaining, wom);
13096     DisplayBlackClock(blackTimeRemaining, !wom);
13097 }
13098
13099
13100 /* Timekeeping seems to be a portability nightmare.  I think everyone
13101    has ftime(), but I'm really not sure, so I'm including some ifdefs
13102    to use other calls if you don't.  Clocks will be less accurate if
13103    you have neither ftime nor gettimeofday.
13104 */
13105
13106 /* VS 2008 requires the #include outside of the function */
13107 #if !HAVE_GETTIMEOFDAY && HAVE_FTIME
13108 #include <sys/timeb.h>
13109 #endif
13110
13111 /* Get the current time as a TimeMark */
13112 void
13113 GetTimeMark(tm)
13114      TimeMark *tm;
13115 {
13116 #if HAVE_GETTIMEOFDAY
13117
13118     struct timeval timeVal;
13119     struct timezone timeZone;
13120
13121     gettimeofday(&timeVal, &timeZone);
13122     tm->sec = (long) timeVal.tv_sec;
13123     tm->ms = (int) (timeVal.tv_usec / 1000L);
13124
13125 #else /*!HAVE_GETTIMEOFDAY*/
13126 #if HAVE_FTIME
13127
13128 // include <sys/timeb.h> / moved to just above start of function
13129     struct timeb timeB;
13130
13131     ftime(&timeB);
13132     tm->sec = (long) timeB.time;
13133     tm->ms = (int) timeB.millitm;
13134
13135 #else /*!HAVE_FTIME && !HAVE_GETTIMEOFDAY*/
13136     tm->sec = (long) time(NULL);
13137     tm->ms = 0;
13138 #endif
13139 #endif
13140 }
13141
13142 /* Return the difference in milliseconds between two
13143    time marks.  We assume the difference will fit in a long!
13144 */
13145 long
13146 SubtractTimeMarks(tm2, tm1)
13147      TimeMark *tm2, *tm1;
13148 {
13149     return 1000L*(tm2->sec - tm1->sec) +
13150            (long) (tm2->ms - tm1->ms);
13151 }
13152
13153
13154 /*
13155  * Code to manage the game clocks.
13156  *
13157  * In tournament play, black starts the clock and then white makes a move.
13158  * We give the human user a slight advantage if he is playing white---the
13159  * clocks don't run until he makes his first move, so it takes zero time.
13160  * Also, we don't account for network lag, so we could get out of sync
13161  * with GNU Chess's clock -- but then, referees are always right.
13162  */
13163
13164 static TimeMark tickStartTM;
13165 static long intendedTickLength;
13166
13167 long
13168 NextTickLength(timeRemaining)
13169      long timeRemaining;
13170 {
13171     long nominalTickLength, nextTickLength;
13172
13173     if (timeRemaining > 0L && timeRemaining <= 10000L)
13174       nominalTickLength = 100L;
13175     else
13176       nominalTickLength = 1000L;
13177     nextTickLength = timeRemaining % nominalTickLength;
13178     if (nextTickLength <= 0) nextTickLength += nominalTickLength;
13179
13180     return nextTickLength;
13181 }
13182
13183 /* Adjust clock one minute up or down */
13184 void
13185 AdjustClock(Boolean which, int dir)
13186 {
13187     if(which) blackTimeRemaining += 60000*dir;
13188     else      whiteTimeRemaining += 60000*dir;
13189     DisplayBothClocks();
13190 }
13191
13192 /* Stop clocks and reset to a fresh time control */
13193 void
13194 ResetClocks()
13195 {
13196     (void) StopClockTimer();
13197     if (appData.icsActive) {
13198         whiteTimeRemaining = blackTimeRemaining = 0;
13199     } else { /* [HGM] correct new time quote for time odds */
13200         whiteTimeRemaining = GetTimeQuota(-1) / WhitePlayer()->timeOdds;
13201         blackTimeRemaining = GetTimeQuota(-1) / WhitePlayer()->other->timeOdds;
13202     }
13203     if (whiteFlag || blackFlag) {
13204         DisplayTitle("");
13205         whiteFlag = blackFlag = FALSE;
13206     }
13207     DisplayBothClocks();
13208 }
13209
13210 #define FUDGE 25 /* 25ms = 1/40 sec; should be plenty even for 50 Hz clocks */
13211
13212 /* Decrement running clock by amount of time that has passed */
13213 void
13214 DecrementClocks()
13215 {
13216     long timeRemaining;
13217     long lastTickLength, fudge;
13218     TimeMark now;
13219
13220     if (!appData.clockMode) return;
13221     if (gameMode==AnalyzeMode || gameMode == AnalyzeFile) return;
13222
13223     GetTimeMark(&now);
13224
13225     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
13226
13227     /* Fudge if we woke up a little too soon */
13228     fudge = intendedTickLength - lastTickLength;
13229     if (fudge < 0 || fudge > FUDGE) fudge = 0;
13230
13231     if (WhiteOnMove(forwardMostMove)) {
13232         if(whiteNPS >= 0) lastTickLength = 0;
13233         timeRemaining = whiteTimeRemaining -= lastTickLength;
13234         DisplayWhiteClock(whiteTimeRemaining - fudge,
13235                           WhiteOnMove(currentMove));
13236     } else {
13237         if(blackNPS >= 0) lastTickLength = 0;
13238         timeRemaining = blackTimeRemaining -= lastTickLength;
13239         DisplayBlackClock(blackTimeRemaining - fudge,
13240                           !WhiteOnMove(currentMove));
13241     }
13242
13243     if (CheckFlags()) return;
13244
13245     tickStartTM = now;
13246     intendedTickLength = NextTickLength(timeRemaining - fudge) + fudge;
13247     StartClockTimer(intendedTickLength);
13248
13249     /* if the time remaining has fallen below the alarm threshold, sound the
13250      * alarm. if the alarm has sounded and (due to a takeback or time control
13251      * with increment) the time remaining has increased to a level above the
13252      * threshold, reset the alarm so it can sound again.
13253      */
13254
13255     if (appData.icsActive && appData.icsAlarm) {
13256
13257         /* make sure we are dealing with the user's clock */
13258         if (!( ((gameMode == IcsPlayingWhite) && WhiteOnMove(currentMove)) ||
13259                ((gameMode == IcsPlayingBlack) && !WhiteOnMove(currentMove))
13260            )) return;
13261
13262         if (alarmSounded && (timeRemaining > appData.icsAlarmTime)) {
13263             alarmSounded = FALSE;
13264         } else if (!alarmSounded && (timeRemaining <= appData.icsAlarmTime)) {
13265             PlayAlarmSound();
13266             alarmSounded = TRUE;
13267         }
13268     }
13269 }
13270
13271
13272 /* A player has just moved, so stop the previously running
13273    clock and (if in clock mode) start the other one.
13274    We redisplay both clocks in case we're in ICS mode, because
13275    ICS gives us an update to both clocks after every move.
13276    Note that this routine is called *after* forwardMostMove
13277    is updated, so the last fractional tick must be subtracted
13278    from the color that is *not* on move now.
13279 */
13280 void
13281 SwitchClocks()
13282 {
13283     long lastTickLength;
13284     TimeMark now;
13285     int flagged = FALSE;
13286
13287     GetTimeMark(&now);
13288
13289     if (StopClockTimer() && appData.clockMode) {
13290         lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
13291         if (WhiteOnMove(forwardMostMove)) {
13292             if(blackNPS >= 0) lastTickLength = 0;
13293             blackTimeRemaining -= lastTickLength;
13294            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
13295 //         if(pvInfoList[forwardMostMove-1].time == -1)
13296                  pvInfoList[forwardMostMove-1].time =               // use GUI time
13297                       (timeRemaining[1][forwardMostMove-1] - blackTimeRemaining)/10;
13298         } else {
13299            if(whiteNPS >= 0) lastTickLength = 0;
13300            whiteTimeRemaining -= lastTickLength;
13301            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
13302 //         if(pvInfoList[forwardMostMove-1].time == -1)
13303                  pvInfoList[forwardMostMove-1].time =
13304                       (timeRemaining[0][forwardMostMove-1] - whiteTimeRemaining)/10;
13305         }
13306         flagged = CheckFlags();
13307     }
13308     CheckTimeControl();
13309
13310     if (flagged || !appData.clockMode) return;
13311
13312     switch (gameMode) {
13313       case MachinePlaysBlack:
13314       case MachinePlaysWhite:
13315       case BeginningOfGame:
13316         if (pausing) return;
13317         break;
13318
13319       case EditGame:
13320       case PlayFromGameFile:
13321       case IcsExamining:
13322         return;
13323
13324       default:
13325         break;
13326     }
13327
13328     tickStartTM = now;
13329     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
13330       whiteTimeRemaining : blackTimeRemaining);
13331     StartClockTimer(intendedTickLength);
13332 }
13333
13334
13335 /* Stop both clocks */
13336 void
13337 StopClocks()
13338 {
13339     long lastTickLength;
13340     TimeMark now;
13341
13342     if (!StopClockTimer()) return;
13343     if (!appData.clockMode) return;
13344
13345     GetTimeMark(&now);
13346
13347     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
13348     if (WhiteOnMove(forwardMostMove)) {
13349         if(whiteNPS >= 0) lastTickLength = 0;
13350         whiteTimeRemaining -= lastTickLength;
13351         DisplayWhiteClock(whiteTimeRemaining, WhiteOnMove(currentMove));
13352     } else {
13353         if(blackNPS >= 0) lastTickLength = 0;
13354         blackTimeRemaining -= lastTickLength;
13355         DisplayBlackClock(blackTimeRemaining, !WhiteOnMove(currentMove));
13356     }
13357     CheckFlags();
13358 }
13359
13360 /* Start clock of player on move.  Time may have been reset, so
13361    if clock is already running, stop and restart it. */
13362 void
13363 StartClocks()
13364 {
13365     (void) StopClockTimer(); /* in case it was running already */
13366     DisplayBothClocks();
13367     if (CheckFlags()) return;
13368
13369     if (!appData.clockMode) return;
13370     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) return;
13371
13372     GetTimeMark(&tickStartTM);
13373     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
13374       whiteTimeRemaining : blackTimeRemaining);
13375
13376    /* [HGM] nps: figure out nps factors, by determining which engine plays white and/or black once and for all */
13377     whiteNPS = blackNPS = -1;
13378     if(gameMode == MachinePlaysWhite || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w'
13379        || appData.zippyPlay && gameMode == IcsPlayingBlack) // first (perhaps only) engine has white
13380         whiteNPS = first.nps;
13381     if(gameMode == MachinePlaysBlack || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b'
13382        || appData.zippyPlay && gameMode == IcsPlayingWhite) // first (perhaps only) engine has black
13383         blackNPS = first.nps;
13384     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b') // second only used in Two-Machines mode
13385         whiteNPS = second.nps;
13386     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w')
13387         blackNPS = second.nps;
13388     if(appData.debugMode) fprintf(debugFP, "nps: w=%d, b=%d\n", whiteNPS, blackNPS);
13389
13390     StartClockTimer(intendedTickLength);
13391 }
13392
13393 char *
13394 TimeString(ms)
13395      long ms;
13396 {
13397     long second, minute, hour, day;
13398     char *sign = "";
13399     static char buf[32];
13400
13401     if (ms > 0 && ms <= 9900) {
13402       /* convert milliseconds to tenths, rounding up */
13403       double tenths = floor( ((double)(ms + 99L)) / 100.00 );
13404
13405       sprintf(buf, " %03.1f ", tenths/10.0);
13406       return buf;
13407     }
13408
13409     /* convert milliseconds to seconds, rounding up */
13410     /* use floating point to avoid strangeness of integer division
13411        with negative dividends on many machines */
13412     second = (long) floor(((double) (ms + 999L)) / 1000.0);
13413
13414     if (second < 0) {
13415         sign = "-";
13416         second = -second;
13417     }
13418
13419     day = second / (60 * 60 * 24);
13420     second = second % (60 * 60 * 24);
13421     hour = second / (60 * 60);
13422     second = second % (60 * 60);
13423     minute = second / 60;
13424     second = second % 60;
13425
13426     if (day > 0)
13427       sprintf(buf, " %s%ld:%02ld:%02ld:%02ld ",
13428               sign, day, hour, minute, second);
13429     else if (hour > 0)
13430       sprintf(buf, " %s%ld:%02ld:%02ld ", sign, hour, minute, second);
13431     else
13432       sprintf(buf, " %s%2ld:%02ld ", sign, minute, second);
13433
13434     return buf;
13435 }
13436
13437
13438 /*
13439  * This is necessary because some C libraries aren't ANSI C compliant yet.
13440  */
13441 char *
13442 StrStr(string, match)
13443      char *string, *match;
13444 {
13445     int i, length;
13446
13447     length = strlen(match);
13448
13449     for (i = strlen(string) - length; i >= 0; i--, string++)
13450       if (!strncmp(match, string, length))
13451         return string;
13452
13453     return NULL;
13454 }
13455
13456 char *
13457 StrCaseStr(string, match)
13458      char *string, *match;
13459 {
13460     int i, j, length;
13461
13462     length = strlen(match);
13463
13464     for (i = strlen(string) - length; i >= 0; i--, string++) {
13465         for (j = 0; j < length; j++) {
13466             if (ToLower(match[j]) != ToLower(string[j]))
13467               break;
13468         }
13469         if (j == length) return string;
13470     }
13471
13472     return NULL;
13473 }
13474
13475 #ifndef _amigados
13476 int
13477 StrCaseCmp(s1, s2)
13478      char *s1, *s2;
13479 {
13480     char c1, c2;
13481
13482     for (;;) {
13483         c1 = ToLower(*s1++);
13484         c2 = ToLower(*s2++);
13485         if (c1 > c2) return 1;
13486         if (c1 < c2) return -1;
13487         if (c1 == NULLCHAR) return 0;
13488     }
13489 }
13490
13491
13492 int
13493 ToLower(c)
13494      int c;
13495 {
13496     return isupper(c) ? tolower(c) : c;
13497 }
13498
13499
13500 int
13501 ToUpper(c)
13502      int c;
13503 {
13504     return islower(c) ? toupper(c) : c;
13505 }
13506 #endif /* !_amigados    */
13507
13508 char *
13509 StrSave(s)
13510      char *s;
13511 {
13512     char *ret;
13513
13514     if ((ret = (char *) malloc(strlen(s) + 1))) {
13515         strcpy(ret, s);
13516     }
13517     return ret;
13518 }
13519
13520 char *
13521 StrSavePtr(s, savePtr)
13522      char *s, **savePtr;
13523 {
13524     if (*savePtr) {
13525         free(*savePtr);
13526     }
13527     if ((*savePtr = (char *) malloc(strlen(s) + 1))) {
13528         strcpy(*savePtr, s);
13529     }
13530     return(*savePtr);
13531 }
13532
13533 char *
13534 PGNDate()
13535 {
13536     time_t clock;
13537     struct tm *tm;
13538     char buf[MSG_SIZ];
13539
13540     clock = time((time_t *)NULL);
13541     tm = localtime(&clock);
13542     sprintf(buf, "%04d.%02d.%02d",
13543             tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
13544     return StrSave(buf);
13545 }
13546
13547
13548 char *
13549 PositionToFEN(move, overrideCastling)
13550      int move;
13551      char *overrideCastling;
13552 {
13553     int i, j, fromX, fromY, toX, toY;
13554     int whiteToPlay;
13555     char buf[128];
13556     char *p, *q;
13557     int emptycount;
13558     ChessSquare piece;
13559
13560     whiteToPlay = (gameMode == EditPosition) ?
13561       !blackPlaysFirst : (move % 2 == 0);
13562     p = buf;
13563
13564     /* Piece placement data */
13565     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
13566         emptycount = 0;
13567         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
13568             if (boards[move][i][j] == EmptySquare) {
13569                 emptycount++;
13570             } else { ChessSquare piece = boards[move][i][j];
13571                 if (emptycount > 0) {
13572                     if(emptycount<10) /* [HGM] can be >= 10 */
13573                         *p++ = '0' + emptycount;
13574                     else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
13575                     emptycount = 0;
13576                 }
13577                 if(PieceToChar(piece) == '+') {
13578                     /* [HGM] write promoted pieces as '+<unpromoted>' (Shogi) */
13579                     *p++ = '+';
13580                     piece = (ChessSquare)(DEMOTED piece);
13581                 }
13582                 *p++ = PieceToChar(piece);
13583                 if(p[-1] == '~') {
13584                     /* [HGM] flag promoted pieces as '<promoted>~' (Crazyhouse) */
13585                     p[-1] = PieceToChar((ChessSquare)(DEMOTED piece));
13586                     *p++ = '~';
13587                 }
13588             }
13589         }
13590         if (emptycount > 0) {
13591             if(emptycount<10) /* [HGM] can be >= 10 */
13592                 *p++ = '0' + emptycount;
13593             else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
13594             emptycount = 0;
13595         }
13596         *p++ = '/';
13597     }
13598     *(p - 1) = ' ';
13599
13600     /* [HGM] print Crazyhouse or Shogi holdings */
13601     if( gameInfo.holdingsWidth ) {
13602         *(p-1) = '['; /* if we wanted to support BFEN, this could be '/' */
13603         q = p;
13604         for(i=0; i<gameInfo.holdingsSize; i++) { /* white holdings */
13605             piece = boards[move][i][BOARD_WIDTH-1];
13606             if( piece != EmptySquare )
13607               for(j=0; j<(int) boards[move][i][BOARD_WIDTH-2]; j++)
13608                   *p++ = PieceToChar(piece);
13609         }
13610         for(i=0; i<gameInfo.holdingsSize; i++) { /* black holdings */
13611             piece = boards[move][BOARD_HEIGHT-i-1][0];
13612             if( piece != EmptySquare )
13613               for(j=0; j<(int) boards[move][BOARD_HEIGHT-i-1][1]; j++)
13614                   *p++ = PieceToChar(piece);
13615         }
13616
13617         if( q == p ) *p++ = '-';
13618         *p++ = ']';
13619         *p++ = ' ';
13620     }
13621
13622     /* Active color */
13623     *p++ = whiteToPlay ? 'w' : 'b';
13624     *p++ = ' ';
13625
13626   if(q = overrideCastling) { // [HGM] FRC: override castling & e.p fields for non-compliant engines
13627     while(*p++ = *q++); if(q != overrideCastling+1) p[-1] = ' ';
13628   } else {
13629   if(nrCastlingRights) {
13630      q = p;
13631      if(gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) {
13632        /* [HGM] write directly from rights */
13633            if(castlingRights[move][2] >= 0 &&
13634               castlingRights[move][0] >= 0   )
13635                 *p++ = castlingRights[move][0] + AAA + 'A' - 'a';
13636            if(castlingRights[move][2] >= 0 &&
13637               castlingRights[move][1] >= 0   )
13638                 *p++ = castlingRights[move][1] + AAA + 'A' - 'a';
13639            if(castlingRights[move][5] >= 0 &&
13640               castlingRights[move][3] >= 0   )
13641                 *p++ = castlingRights[move][3] + AAA;
13642            if(castlingRights[move][5] >= 0 &&
13643               castlingRights[move][4] >= 0   )
13644                 *p++ = castlingRights[move][4] + AAA;
13645      } else {
13646
13647         /* [HGM] write true castling rights */
13648         if( nrCastlingRights == 6 ) {
13649             if(castlingRights[move][0] == BOARD_RGHT-1 &&
13650                castlingRights[move][2] >= 0  ) *p++ = 'K';
13651             if(castlingRights[move][1] == BOARD_LEFT &&
13652                castlingRights[move][2] >= 0  ) *p++ = 'Q';
13653             if(castlingRights[move][3] == BOARD_RGHT-1 &&
13654                castlingRights[move][5] >= 0  ) *p++ = 'k';
13655             if(castlingRights[move][4] == BOARD_LEFT &&
13656                castlingRights[move][5] >= 0  ) *p++ = 'q';
13657         }
13658      }
13659      if (q == p) *p++ = '-'; /* No castling rights */
13660      *p++ = ' ';
13661   }
13662
13663   if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
13664      gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier ) {
13665     /* En passant target square */
13666     if (move > backwardMostMove) {
13667         fromX = moveList[move - 1][0] - AAA;
13668         fromY = moveList[move - 1][1] - ONE;
13669         toX = moveList[move - 1][2] - AAA;
13670         toY = moveList[move - 1][3] - ONE;
13671         if (fromY == (whiteToPlay ? BOARD_HEIGHT-2 : 1) &&
13672             toY == (whiteToPlay ? BOARD_HEIGHT-4 : 3) &&
13673             boards[move][toY][toX] == (whiteToPlay ? BlackPawn : WhitePawn) &&
13674             fromX == toX) {
13675             /* 2-square pawn move just happened */
13676             *p++ = toX + AAA;
13677             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
13678         } else {
13679             *p++ = '-';
13680         }
13681     } else if(move == backwardMostMove) {
13682         // [HGM] perhaps we should always do it like this, and forget the above?
13683         if(epStatus[move] >= 0) {
13684             *p++ = epStatus[move] + AAA;
13685             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
13686         } else {
13687             *p++ = '-';
13688         }
13689     } else {
13690         *p++ = '-';
13691     }
13692     *p++ = ' ';
13693   }
13694   }
13695
13696     /* [HGM] find reversible plies */
13697     {   int i = 0, j=move;
13698
13699         if (appData.debugMode) { int k;
13700             fprintf(debugFP, "write FEN 50-move: %d %d %d\n", initialRulePlies, forwardMostMove, backwardMostMove);
13701             for(k=backwardMostMove; k<=forwardMostMove; k++)
13702                 fprintf(debugFP, "e%d. p=%d\n", k, epStatus[k]);
13703
13704         }
13705
13706         while(j > backwardMostMove && epStatus[j] <= EP_NONE) j--,i++;
13707         if( j == backwardMostMove ) i += initialRulePlies;
13708         sprintf(p, "%d ", i);
13709         p += i>=100 ? 4 : i >= 10 ? 3 : 2;
13710     }
13711     /* Fullmove number */
13712     sprintf(p, "%d", (move / 2) + 1);
13713
13714     return StrSave(buf);
13715 }
13716
13717 Boolean
13718 ParseFEN(board, blackPlaysFirst, fen)
13719     Board board;
13720      int *blackPlaysFirst;
13721      char *fen;
13722 {
13723     int i, j;
13724     char *p;
13725     int emptycount;
13726     ChessSquare piece;
13727
13728     p = fen;
13729
13730     /* [HGM] by default clear Crazyhouse holdings, if present */
13731     if(gameInfo.holdingsWidth) {
13732        for(i=0; i<BOARD_HEIGHT; i++) {
13733            board[i][0]             = EmptySquare; /* black holdings */
13734            board[i][BOARD_WIDTH-1] = EmptySquare; /* white holdings */
13735            board[i][1]             = (ChessSquare) 0; /* black counts */
13736            board[i][BOARD_WIDTH-2] = (ChessSquare) 0; /* white counts */
13737        }
13738     }
13739
13740     /* Piece placement data */
13741     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
13742         j = 0;
13743         for (;;) {
13744             if (*p == '/' || *p == ' ' || (*p == '[' && i == 0) ) {
13745                 if (*p == '/') p++;
13746                 emptycount = gameInfo.boardWidth - j;
13747                 while (emptycount--)
13748                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
13749                 break;
13750 #if(BOARD_SIZE >= 10)
13751             } else if(*p=='x' || *p=='X') { /* [HGM] X means 10 */
13752                 p++; emptycount=10;
13753                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
13754                 while (emptycount--)
13755                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
13756 #endif
13757             } else if (isdigit(*p)) {
13758                 emptycount = *p++ - '0';
13759                 while(isdigit(*p)) emptycount = 10*emptycount + *p++ - '0'; /* [HGM] allow > 9 */
13760                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
13761                 while (emptycount--)
13762                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
13763             } else if (*p == '+' || isalpha(*p)) {
13764                 if (j >= gameInfo.boardWidth) return FALSE;
13765                 if(*p=='+') {
13766                     piece = CharToPiece(*++p);
13767                     if(piece == EmptySquare) return FALSE; /* unknown piece */
13768                     piece = (ChessSquare) (PROMOTED piece ); p++;
13769                     if(PieceToChar(piece) != '+') return FALSE; /* unpromotable piece */
13770                 } else piece = CharToPiece(*p++);
13771
13772                 if(piece==EmptySquare) return FALSE; /* unknown piece */
13773                 if(*p == '~') { /* [HGM] make it a promoted piece for Crazyhouse */
13774                     piece = (ChessSquare) (PROMOTED piece);
13775                     if(PieceToChar(piece) != '~') return FALSE; /* cannot be a promoted piece */
13776                     p++;
13777                 }
13778                 board[i][(j++)+gameInfo.holdingsWidth] = piece;
13779             } else {
13780                 return FALSE;
13781             }
13782         }
13783     }
13784     while (*p == '/' || *p == ' ') p++;
13785
13786     /* [HGM] look for Crazyhouse holdings here */
13787     while(*p==' ') p++;
13788     if( gameInfo.holdingsWidth && p[-1] == '/' || *p == '[') {
13789         if(*p == '[') p++;
13790         if(*p == '-' ) *p++; /* empty holdings */ else {
13791             if( !gameInfo.holdingsWidth ) return FALSE; /* no room to put holdings! */
13792             /* if we would allow FEN reading to set board size, we would   */
13793             /* have to add holdings and shift the board read so far here   */
13794             while( (piece = CharToPiece(*p) ) != EmptySquare ) {
13795                 *p++;
13796                 if((int) piece >= (int) BlackPawn ) {
13797                     i = (int)piece - (int)BlackPawn;
13798                     i = PieceToNumber((ChessSquare)i);
13799                     if( i >= gameInfo.holdingsSize ) return FALSE;
13800                     board[BOARD_HEIGHT-1-i][0] = piece; /* black holdings */
13801                     board[BOARD_HEIGHT-1-i][1]++;       /* black counts   */
13802                 } else {
13803                     i = (int)piece - (int)WhitePawn;
13804                     i = PieceToNumber((ChessSquare)i);
13805                     if( i >= gameInfo.holdingsSize ) return FALSE;
13806                     board[i][BOARD_WIDTH-1] = piece;    /* white holdings */
13807                     board[i][BOARD_WIDTH-2]++;          /* black holdings */
13808                 }
13809             }
13810         }
13811         if(*p == ']') *p++;
13812     }
13813
13814     while(*p == ' ') p++;
13815
13816     /* Active color */
13817     switch (*p++) {
13818       case 'w':
13819         *blackPlaysFirst = FALSE;
13820         break;
13821       case 'b':
13822         *blackPlaysFirst = TRUE;
13823         break;
13824       default:
13825         return FALSE;
13826     }
13827
13828     /* [HGM] We NO LONGER ignore the rest of the FEN notation */
13829     /* return the extra info in global variiables             */
13830
13831     /* set defaults in case FEN is incomplete */
13832     FENepStatus = EP_UNKNOWN;
13833     for(i=0; i<nrCastlingRights; i++ ) {
13834         FENcastlingRights[i] =
13835             gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom ? -1 : initialRights[i];
13836     }   /* assume possible unless obviously impossible */
13837     if(initialRights[0]>=0 && board[castlingRank[0]][initialRights[0]] != WhiteRook) FENcastlingRights[0] = -1;
13838     if(initialRights[1]>=0 && board[castlingRank[1]][initialRights[1]] != WhiteRook) FENcastlingRights[1] = -1;
13839     if(initialRights[2]>=0 && board[castlingRank[2]][initialRights[2]] != WhiteKing) FENcastlingRights[2] = -1;
13840     if(initialRights[3]>=0 && board[castlingRank[3]][initialRights[3]] != BlackRook) FENcastlingRights[3] = -1;
13841     if(initialRights[4]>=0 && board[castlingRank[4]][initialRights[4]] != BlackRook) FENcastlingRights[4] = -1;
13842     if(initialRights[5]>=0 && board[castlingRank[5]][initialRights[5]] != BlackKing) FENcastlingRights[5] = -1;
13843     FENrulePlies = 0;
13844
13845     while(*p==' ') p++;
13846     if(nrCastlingRights) {
13847       if(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-') {
13848           /* castling indicator present, so default becomes no castlings */
13849           for(i=0; i<nrCastlingRights; i++ ) {
13850                  FENcastlingRights[i] = -1;
13851           }
13852       }
13853       while(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-' ||
13854              (gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) &&
13855              ( *p >= 'a' && *p < 'a' + gameInfo.boardWidth) ||
13856              ( *p >= 'A' && *p < 'A' + gameInfo.boardWidth)   ) {
13857         char c = *p++; int whiteKingFile=-1, blackKingFile=-1;
13858
13859         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
13860             if(board[BOARD_HEIGHT-1][i] == BlackKing) blackKingFile = i;
13861             if(board[0             ][i] == WhiteKing) whiteKingFile = i;
13862         }
13863         switch(c) {
13864           case'K':
13865               for(i=BOARD_RGHT-1; board[0][i]!=WhiteRook && i>whiteKingFile; i--);
13866               FENcastlingRights[0] = i != whiteKingFile ? i : -1;
13867               FENcastlingRights[2] = whiteKingFile;
13868               break;
13869           case'Q':
13870               for(i=BOARD_LEFT; board[0][i]!=WhiteRook && i<whiteKingFile; i++);
13871               FENcastlingRights[1] = i != whiteKingFile ? i : -1;
13872               FENcastlingRights[2] = whiteKingFile;
13873               break;
13874           case'k':
13875               for(i=BOARD_RGHT-1; board[BOARD_HEIGHT-1][i]!=BlackRook && i>blackKingFile; i--);
13876               FENcastlingRights[3] = i != blackKingFile ? i : -1;
13877               FENcastlingRights[5] = blackKingFile;
13878               break;
13879           case'q':
13880               for(i=BOARD_LEFT; board[BOARD_HEIGHT-1][i]!=BlackRook && i<blackKingFile; i++);
13881               FENcastlingRights[4] = i != blackKingFile ? i : -1;
13882               FENcastlingRights[5] = blackKingFile;
13883           case '-':
13884               break;
13885           default: /* FRC castlings */
13886               if(c >= 'a') { /* black rights */
13887                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
13888                     if(board[BOARD_HEIGHT-1][i] == BlackKing) break;
13889                   if(i == BOARD_RGHT) break;
13890                   FENcastlingRights[5] = i;
13891                   c -= AAA;
13892                   if(board[BOARD_HEIGHT-1][c] <  BlackPawn ||
13893                      board[BOARD_HEIGHT-1][c] >= BlackKing   ) break;
13894                   if(c > i)
13895                       FENcastlingRights[3] = c;
13896                   else
13897                       FENcastlingRights[4] = c;
13898               } else { /* white rights */
13899                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
13900                     if(board[0][i] == WhiteKing) break;
13901                   if(i == BOARD_RGHT) break;
13902                   FENcastlingRights[2] = i;
13903                   c -= AAA - 'a' + 'A';
13904                   if(board[0][c] >= WhiteKing) break;
13905                   if(c > i)
13906                       FENcastlingRights[0] = c;
13907                   else
13908                       FENcastlingRights[1] = c;
13909               }
13910         }
13911       }
13912     if (appData.debugMode) {
13913         fprintf(debugFP, "FEN castling rights:");
13914         for(i=0; i<nrCastlingRights; i++)
13915         fprintf(debugFP, " %d", FENcastlingRights[i]);
13916         fprintf(debugFP, "\n");
13917     }
13918
13919       while(*p==' ') p++;
13920     }
13921
13922     /* read e.p. field in games that know e.p. capture */
13923     if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
13924        gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier ) {
13925       if(*p=='-') {
13926         p++; FENepStatus = EP_NONE;
13927       } else {
13928          char c = *p++ - AAA;
13929
13930          if(c < BOARD_LEFT || c >= BOARD_RGHT) return TRUE;
13931          if(*p >= '0' && *p <='9') *p++;
13932          FENepStatus = c;
13933       }
13934     }
13935
13936
13937     if(sscanf(p, "%d", &i) == 1) {
13938         FENrulePlies = i; /* 50-move ply counter */
13939         /* (The move number is still ignored)    */
13940     }
13941
13942     return TRUE;
13943 }
13944
13945 void
13946 EditPositionPasteFEN(char *fen)
13947 {
13948   if (fen != NULL) {
13949     Board initial_position;
13950
13951     if (!ParseFEN(initial_position, &blackPlaysFirst, fen)) {
13952       DisplayError(_("Bad FEN position in clipboard"), 0);
13953       return ;
13954     } else {
13955       int savedBlackPlaysFirst = blackPlaysFirst;
13956       EditPositionEvent();
13957       blackPlaysFirst = savedBlackPlaysFirst;
13958       CopyBoard(boards[0], initial_position);
13959           /* [HGM] copy FEN attributes as well */
13960           {   int i;
13961               initialRulePlies = FENrulePlies;
13962               epStatus[0] = FENepStatus;
13963               for( i=0; i<nrCastlingRights; i++ )
13964                   castlingRights[0][i] = FENcastlingRights[i];
13965           }
13966       EditPositionDone();
13967       DisplayBothClocks();
13968       DrawPosition(FALSE, boards[currentMove]);
13969     }
13970   }
13971 }
13972
13973 static char cseq[12] = "\\   ";
13974
13975 Boolean set_cont_sequence(char *new_seq)
13976 {
13977     int len;
13978     Boolean ret;
13979
13980     // handle bad attempts to set the sequence
13981         if (!new_seq)
13982                 return 0; // acceptable error - no debug
13983
13984     len = strlen(new_seq);
13985     ret = (len > 0) && (len < sizeof(cseq));
13986     if (ret)
13987         strcpy(cseq, new_seq);
13988     else if (appData.debugMode)
13989         fprintf(debugFP, "Invalid continuation sequence \"%s\"  (maximum length is: %d)\n", new_seq, sizeof(cseq)-1);
13990     return ret;
13991 }
13992
13993 /*
13994     reformat a source message so words don't cross the width boundary.  internal
13995     newlines are not removed.  returns the wrapped size (no null character unless
13996     included in source message).  If dest is NULL, only calculate the size required
13997     for the dest buffer.  lp argument indicats line position upon entry, and it's
13998     passed back upon exit.
13999 */
14000 int wrap(char *dest, char *src, int count, int width, int *lp)
14001 {
14002     int len, i, ansi, cseq_len, line, old_line, old_i, old_len, clen;
14003
14004     cseq_len = strlen(cseq);
14005     old_line = line = *lp;
14006     ansi = len = clen = 0;
14007
14008     for (i=0; i < count; i++)
14009     {
14010         if (src[i] == '\033')
14011             ansi = 1;
14012
14013         // if we hit the width, back up
14014         if (!ansi && (line >= width) && src[i] != '\n' && src[i] != ' ')
14015         {
14016             // store i & len in case the word is too long
14017             old_i = i, old_len = len;
14018
14019             // find the end of the last word
14020             while (i && src[i] != ' ' && src[i] != '\n')
14021             {
14022                 i--;
14023                 len--;
14024             }
14025
14026             // word too long?  restore i & len before splitting it
14027             if ((old_i-i+clen) >= width)
14028             {
14029                 i = old_i;
14030                 len = old_len;
14031             }
14032
14033             // extra space?
14034             if (i && src[i-1] == ' ')
14035                 len--;
14036
14037             if (src[i] != ' ' && src[i] != '\n')
14038             {
14039                 i--;
14040                 if (len)
14041                     len--;
14042             }
14043
14044             // now append the newline and continuation sequence
14045             if (dest)
14046                 dest[len] = '\n';
14047             len++;
14048             if (dest)
14049                 strncpy(dest+len, cseq, cseq_len);
14050             len += cseq_len;
14051             line = cseq_len;
14052             clen = cseq_len;
14053             continue;
14054         }
14055
14056         if (dest)
14057             dest[len] = src[i];
14058         len++;
14059         if (!ansi)
14060             line++;
14061         if (src[i] == '\n')
14062             line = 0;
14063         if (src[i] == 'm')
14064             ansi = 0;
14065     }
14066     if (dest && appData.debugMode)
14067     {
14068         fprintf(debugFP, "wrap(count:%d,width:%d,line:%d,len:%d,*lp:%d,src: ",
14069             count, width, line, len, *lp);
14070         show_bytes(debugFP, src, count);
14071         fprintf(debugFP, "\ndest: ");
14072         show_bytes(debugFP, dest, len);
14073         fprintf(debugFP, "\n");
14074     }
14075     *lp = dest ? line : old_line;
14076
14077     return len;
14078 }