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     if (appData.matchGames > 0) {
1046         appData.matchMode = TRUE;
1047     } else if (appData.matchMode) {
1048         appData.matchGames = 1;
1049     }
1050     if(appData.matchMode && appData.sameColorGames > 0) /* [HGM] alternate: overrule matchGames */
1051         appData.matchGames = appData.sameColorGames;
1052     if(appData.rewindIndex > 1) { /* [HGM] autoinc: rewind implies auto-increment and overrules given index */
1053         if(appData.loadPositionIndex >= 0) appData.loadPositionIndex = -1;
1054         if(appData.loadGameIndex >= 0) appData.loadGameIndex = -1;
1055     }
1056     Reset(TRUE, FALSE);
1057     if (appData.noChessProgram || first.protocolVersion == 1) {
1058       InitBackEnd3();
1059     } else {
1060       /* kludge: allow timeout for initial "feature" commands */
1061       FreezeUI();
1062       DisplayMessage("", _("Starting chess program"));
1063       ScheduleDelayedEvent(InitBackEnd3, FEATURE_TIMEOUT);
1064     }
1065 }
1066
1067 void
1068 InitBackEnd3 P((void))
1069 {
1070     GameMode initialMode;
1071     char buf[MSG_SIZ];
1072     int err;
1073
1074     InitChessProgram(&first, startedFromSetupPosition);
1075
1076
1077     if (appData.icsActive) {
1078 #ifdef WIN32
1079         /* [DM] Make a console window if needed [HGM] merged ifs */
1080         ConsoleCreate();
1081 #endif
1082         err = establish();
1083         if (err != 0) {
1084             if (*appData.icsCommPort != NULLCHAR) {
1085                 sprintf(buf, _("Could not open comm port %s"),
1086                         appData.icsCommPort);
1087             } else {
1088                 snprintf(buf, sizeof(buf), _("Could not connect to host %s, port %s"),
1089                         appData.icsHost, appData.icsPort);
1090             }
1091             DisplayFatalError(buf, err, 1);
1092             return;
1093         }
1094         SetICSMode();
1095         telnetISR =
1096           AddInputSource(icsPR, FALSE, read_from_ics, &telnetISR);
1097         fromUserISR =
1098           AddInputSource(NoProc, FALSE, read_from_player, &fromUserISR);
1099     } else if (appData.noChessProgram) {
1100         SetNCPMode();
1101     } else {
1102         SetGNUMode();
1103     }
1104
1105     if (*appData.cmailGameName != NULLCHAR) {
1106         SetCmailMode();
1107         OpenLoopback(&cmailPR);
1108         cmailISR =
1109           AddInputSource(cmailPR, FALSE, CmailSigHandlerCallBack, &cmailISR);
1110     }
1111
1112     ThawUI();
1113     DisplayMessage("", "");
1114     if (StrCaseCmp(appData.initialMode, "") == 0) {
1115       initialMode = BeginningOfGame;
1116     } else if (StrCaseCmp(appData.initialMode, "TwoMachines") == 0) {
1117       initialMode = TwoMachinesPlay;
1118     } else if (StrCaseCmp(appData.initialMode, "AnalyzeFile") == 0) {
1119       initialMode = AnalyzeFile;
1120     } else if (StrCaseCmp(appData.initialMode, "Analysis") == 0) {
1121       initialMode = AnalyzeMode;
1122     } else if (StrCaseCmp(appData.initialMode, "MachineWhite") == 0) {
1123       initialMode = MachinePlaysWhite;
1124     } else if (StrCaseCmp(appData.initialMode, "MachineBlack") == 0) {
1125       initialMode = MachinePlaysBlack;
1126     } else if (StrCaseCmp(appData.initialMode, "EditGame") == 0) {
1127       initialMode = EditGame;
1128     } else if (StrCaseCmp(appData.initialMode, "EditPosition") == 0) {
1129       initialMode = EditPosition;
1130     } else if (StrCaseCmp(appData.initialMode, "Training") == 0) {
1131       initialMode = Training;
1132     } else {
1133       sprintf(buf, _("Unknown initialMode %s"), appData.initialMode);
1134       DisplayFatalError(buf, 0, 2);
1135       return;
1136     }
1137
1138     if (appData.matchMode) {
1139         /* Set up machine vs. machine match */
1140         if (appData.noChessProgram) {
1141             DisplayFatalError(_("Can't have a match with no chess programs"),
1142                               0, 2);
1143             return;
1144         }
1145         matchMode = TRUE;
1146         matchGame = 1;
1147         if (*appData.loadGameFile != NULLCHAR) {
1148             int index = appData.loadGameIndex; // [HGM] autoinc
1149             if(index<0) lastIndex = index = 1;
1150             if (!LoadGameFromFile(appData.loadGameFile,
1151                                   index,
1152                                   appData.loadGameFile, FALSE)) {
1153                 DisplayFatalError(_("Bad game file"), 0, 1);
1154                 return;
1155             }
1156         } else if (*appData.loadPositionFile != NULLCHAR) {
1157             int index = appData.loadPositionIndex; // [HGM] autoinc
1158             if(index<0) lastIndex = index = 1;
1159             if (!LoadPositionFromFile(appData.loadPositionFile,
1160                                       index,
1161                                       appData.loadPositionFile)) {
1162                 DisplayFatalError(_("Bad position file"), 0, 1);
1163                 return;
1164             }
1165         }
1166         TwoMachinesEvent();
1167     } else if (*appData.cmailGameName != NULLCHAR) {
1168         /* Set up cmail mode */
1169         ReloadCmailMsgEvent(TRUE);
1170     } else {
1171         /* Set up other modes */
1172         if (initialMode == AnalyzeFile) {
1173           if (*appData.loadGameFile == NULLCHAR) {
1174             DisplayFatalError(_("AnalyzeFile mode requires a game file"), 0, 1);
1175             return;
1176           }
1177         }
1178         if (*appData.loadGameFile != NULLCHAR) {
1179             (void) LoadGameFromFile(appData.loadGameFile,
1180                                     appData.loadGameIndex,
1181                                     appData.loadGameFile, TRUE);
1182         } else if (*appData.loadPositionFile != NULLCHAR) {
1183             (void) LoadPositionFromFile(appData.loadPositionFile,
1184                                         appData.loadPositionIndex,
1185                                         appData.loadPositionFile);
1186             /* [HGM] try to make self-starting even after FEN load */
1187             /* to allow automatic setup of fairy variants with wtm */
1188             if(initialMode == BeginningOfGame && !blackPlaysFirst) {
1189                 gameMode = BeginningOfGame;
1190                 setboardSpoiledMachineBlack = 1;
1191             }
1192             /* [HGM] loadPos: make that every new game uses the setup */
1193             /* from file as long as we do not switch variant          */
1194             if(!blackPlaysFirst) { int i;
1195                 startedFromPositionFile = TRUE;
1196                 CopyBoard(filePosition, boards[0]);
1197                 for(i=0; i<BOARD_SIZE; i++) fileRights[i] = castlingRights[0][i];
1198             }
1199         }
1200         if (initialMode == AnalyzeMode) {
1201           if (appData.noChessProgram) {
1202             DisplayFatalError(_("Analysis mode requires a chess engine"), 0, 2);
1203             return;
1204           }
1205           if (appData.icsActive) {
1206             DisplayFatalError(_("Analysis mode does not work with ICS mode"),0,2);
1207             return;
1208           }
1209           AnalyzeModeEvent();
1210         } else if (initialMode == AnalyzeFile) {
1211           appData.showThinking = TRUE; // [HGM] thinking: moved out of ShowThinkingEvent
1212           ShowThinkingEvent();
1213           AnalyzeFileEvent();
1214           AnalysisPeriodicEvent(1);
1215         } else if (initialMode == MachinePlaysWhite) {
1216           if (appData.noChessProgram) {
1217             DisplayFatalError(_("MachineWhite mode requires a chess engine"),
1218                               0, 2);
1219             return;
1220           }
1221           if (appData.icsActive) {
1222             DisplayFatalError(_("MachineWhite mode does not work with ICS mode"),
1223                               0, 2);
1224             return;
1225           }
1226           MachineWhiteEvent();
1227         } else if (initialMode == MachinePlaysBlack) {
1228           if (appData.noChessProgram) {
1229             DisplayFatalError(_("MachineBlack mode requires a chess engine"),
1230                               0, 2);
1231             return;
1232           }
1233           if (appData.icsActive) {
1234             DisplayFatalError(_("MachineBlack mode does not work with ICS mode"),
1235                               0, 2);
1236             return;
1237           }
1238           MachineBlackEvent();
1239         } else if (initialMode == TwoMachinesPlay) {
1240           if (appData.noChessProgram) {
1241             DisplayFatalError(_("TwoMachines mode requires a chess engine"),
1242                               0, 2);
1243             return;
1244           }
1245           if (appData.icsActive) {
1246             DisplayFatalError(_("TwoMachines mode does not work with ICS mode"),
1247                               0, 2);
1248             return;
1249           }
1250           TwoMachinesEvent();
1251         } else if (initialMode == EditGame) {
1252           EditGameEvent();
1253         } else if (initialMode == EditPosition) {
1254           EditPositionEvent();
1255         } else if (initialMode == Training) {
1256           if (*appData.loadGameFile == NULLCHAR) {
1257             DisplayFatalError(_("Training mode requires a game file"), 0, 2);
1258             return;
1259           }
1260           TrainingEvent();
1261         }
1262     }
1263 }
1264
1265 /*
1266  * Establish will establish a contact to a remote host.port.
1267  * Sets icsPR to a ProcRef for a process (or pseudo-process)
1268  *  used to talk to the host.
1269  * Returns 0 if okay, error code if not.
1270  */
1271 int
1272 establish()
1273 {
1274     char buf[MSG_SIZ];
1275
1276     if (*appData.icsCommPort != NULLCHAR) {
1277         /* Talk to the host through a serial comm port */
1278         return OpenCommPort(appData.icsCommPort, &icsPR);
1279
1280     } else if (*appData.gateway != NULLCHAR) {
1281         if (*appData.remoteShell == NULLCHAR) {
1282             /* Use the rcmd protocol to run telnet program on a gateway host */
1283             snprintf(buf, sizeof(buf), "%s %s %s",
1284                     appData.telnetProgram, appData.icsHost, appData.icsPort);
1285             return OpenRcmd(appData.gateway, appData.remoteUser, buf, &icsPR);
1286
1287         } else {
1288             /* Use the rsh program to run telnet program on a gateway host */
1289             if (*appData.remoteUser == NULLCHAR) {
1290                 snprintf(buf, sizeof(buf), "%s %s %s %s %s", appData.remoteShell,
1291                         appData.gateway, appData.telnetProgram,
1292                         appData.icsHost, appData.icsPort);
1293             } else {
1294                 snprintf(buf, sizeof(buf), "%s %s -l %s %s %s %s",
1295                         appData.remoteShell, appData.gateway,
1296                         appData.remoteUser, appData.telnetProgram,
1297                         appData.icsHost, appData.icsPort);
1298             }
1299             return StartChildProcess(buf, "", &icsPR);
1300
1301         }
1302     } else if (appData.useTelnet) {
1303         return OpenTelnet(appData.icsHost, appData.icsPort, &icsPR);
1304
1305     } else {
1306         /* TCP socket interface differs somewhat between
1307            Unix and NT; handle details in the front end.
1308            */
1309         return OpenTCP(appData.icsHost, appData.icsPort, &icsPR);
1310     }
1311 }
1312
1313 void
1314 show_bytes(fp, buf, count)
1315      FILE *fp;
1316      char *buf;
1317      int count;
1318 {
1319     while (count--) {
1320         if (*buf < 040 || *(unsigned char *) buf > 0177) {
1321             fprintf(fp, "\\%03o", *buf & 0xff);
1322         } else {
1323             putc(*buf, fp);
1324         }
1325         buf++;
1326     }
1327     fflush(fp);
1328 }
1329
1330 /* Returns an errno value */
1331 int
1332 OutputMaybeTelnet(pr, message, count, outError)
1333      ProcRef pr;
1334      char *message;
1335      int count;
1336      int *outError;
1337 {
1338     char buf[8192], *p, *q, *buflim;
1339     int left, newcount, outcount;
1340
1341     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet ||
1342         *appData.gateway != NULLCHAR) {
1343         if (appData.debugMode) {
1344             fprintf(debugFP, ">ICS: ");
1345             show_bytes(debugFP, message, count);
1346             fprintf(debugFP, "\n");
1347         }
1348         return OutputToProcess(pr, message, count, outError);
1349     }
1350
1351     buflim = &buf[sizeof(buf)-1]; /* allow 1 byte for expanding last char */
1352     p = message;
1353     q = buf;
1354     left = count;
1355     newcount = 0;
1356     while (left) {
1357         if (q >= buflim) {
1358             if (appData.debugMode) {
1359                 fprintf(debugFP, ">ICS: ");
1360                 show_bytes(debugFP, buf, newcount);
1361                 fprintf(debugFP, "\n");
1362             }
1363             outcount = OutputToProcess(pr, buf, newcount, outError);
1364             if (outcount < newcount) return -1; /* to be sure */
1365             q = buf;
1366             newcount = 0;
1367         }
1368         if (*p == '\n') {
1369             *q++ = '\r';
1370             newcount++;
1371         } else if (((unsigned char) *p) == TN_IAC) {
1372             *q++ = (char) TN_IAC;
1373             newcount ++;
1374         }
1375         *q++ = *p++;
1376         newcount++;
1377         left--;
1378     }
1379     if (appData.debugMode) {
1380         fprintf(debugFP, ">ICS: ");
1381         show_bytes(debugFP, buf, newcount);
1382         fprintf(debugFP, "\n");
1383     }
1384     outcount = OutputToProcess(pr, buf, newcount, outError);
1385     if (outcount < newcount) return -1; /* to be sure */
1386     return count;
1387 }
1388
1389 void
1390 read_from_player(isr, closure, message, count, error)
1391      InputSourceRef isr;
1392      VOIDSTAR closure;
1393      char *message;
1394      int count;
1395      int error;
1396 {
1397     int outError, outCount;
1398     static int gotEof = 0;
1399
1400     /* Pass data read from player on to ICS */
1401     if (count > 0) {
1402         gotEof = 0;
1403         outCount = OutputMaybeTelnet(icsPR, message, count, &outError);
1404         if (outCount < count) {
1405             DisplayFatalError(_("Error writing to ICS"), outError, 1);
1406         }
1407     } else if (count < 0) {
1408         RemoveInputSource(isr);
1409         DisplayFatalError(_("Error reading from keyboard"), error, 1);
1410     } else if (gotEof++ > 0) {
1411         RemoveInputSource(isr);
1412         DisplayFatalError(_("Got end of file from keyboard"), 0, 0);
1413     }
1414 }
1415
1416 void
1417 KeepAlive()
1418 {   // [HGM] alive: periodically send dummy (date) command to ICS to prevent time-out
1419     SendToICS("date\n");
1420     if(appData.keepAlive) ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1421 }
1422
1423 /* added routine for printf style output to ics */
1424 void ics_printf(char *format, ...)
1425 {
1426     char buffer[MSG_SIZ];
1427     va_list args;
1428
1429     va_start(args, format);
1430     vsnprintf(buffer, sizeof(buffer), format, args);
1431     buffer[sizeof(buffer)-1] = '\0';
1432     SendToICS(buffer);
1433     va_end(args);
1434 }
1435
1436 void
1437 SendToICS(s)
1438      char *s;
1439 {
1440     int count, outCount, outError;
1441
1442     if (icsPR == NULL) return;
1443
1444     count = strlen(s);
1445     outCount = OutputMaybeTelnet(icsPR, s, count, &outError);
1446     if (outCount < count) {
1447         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1448     }
1449 }
1450
1451 /* This is used for sending logon scripts to the ICS. Sending
1452    without a delay causes problems when using timestamp on ICC
1453    (at least on my machine). */
1454 void
1455 SendToICSDelayed(s,msdelay)
1456      char *s;
1457      long msdelay;
1458 {
1459     int count, outCount, outError;
1460
1461     if (icsPR == NULL) return;
1462
1463     count = strlen(s);
1464     if (appData.debugMode) {
1465         fprintf(debugFP, ">ICS: ");
1466         show_bytes(debugFP, s, count);
1467         fprintf(debugFP, "\n");
1468     }
1469     outCount = OutputToProcessDelayed(icsPR, s, count, &outError,
1470                                       msdelay);
1471     if (outCount < count) {
1472         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1473     }
1474 }
1475
1476
1477 /* Remove all highlighting escape sequences in s
1478    Also deletes any suffix starting with '('
1479    */
1480 char *
1481 StripHighlightAndTitle(s)
1482      char *s;
1483 {
1484     static char retbuf[MSG_SIZ];
1485     char *p = retbuf;
1486
1487     while (*s != NULLCHAR) {
1488         while (*s == '\033') {
1489             while (*s != NULLCHAR && !isalpha(*s)) s++;
1490             if (*s != NULLCHAR) s++;
1491         }
1492         while (*s != NULLCHAR && *s != '\033') {
1493             if (*s == '(' || *s == '[') {
1494                 *p = NULLCHAR;
1495                 return retbuf;
1496             }
1497             *p++ = *s++;
1498         }
1499     }
1500     *p = NULLCHAR;
1501     return retbuf;
1502 }
1503
1504 /* Remove all highlighting escape sequences in s */
1505 char *
1506 StripHighlight(s)
1507      char *s;
1508 {
1509     static char retbuf[MSG_SIZ];
1510     char *p = retbuf;
1511
1512     while (*s != NULLCHAR) {
1513         while (*s == '\033') {
1514             while (*s != NULLCHAR && !isalpha(*s)) s++;
1515             if (*s != NULLCHAR) s++;
1516         }
1517         while (*s != NULLCHAR && *s != '\033') {
1518             *p++ = *s++;
1519         }
1520     }
1521     *p = NULLCHAR;
1522     return retbuf;
1523 }
1524
1525 char *variantNames[] = VARIANT_NAMES;
1526 char *
1527 VariantName(v)
1528      VariantClass v;
1529 {
1530     return variantNames[v];
1531 }
1532
1533
1534 /* Identify a variant from the strings the chess servers use or the
1535    PGN Variant tag names we use. */
1536 VariantClass
1537 StringToVariant(e)
1538      char *e;
1539 {
1540     char *p;
1541     int wnum = -1;
1542     VariantClass v = VariantNormal;
1543     int i, found = FALSE;
1544     char buf[MSG_SIZ];
1545
1546     if (!e) return v;
1547
1548     /* [HGM] skip over optional board-size prefixes */
1549     if( sscanf(e, "%dx%d_", &i, &i) == 2 ||
1550         sscanf(e, "%dx%d+%d_", &i, &i, &i) == 3 ) {
1551         while( *e++ != '_');
1552     }
1553
1554     if(StrCaseStr(e, "misc/")) { // [HGM] on FICS, misc/shogi is not shogi
1555         v = VariantNormal;
1556         found = TRUE;
1557     } else
1558     for (i=0; i<sizeof(variantNames)/sizeof(char*); i++) {
1559       if (StrCaseStr(e, variantNames[i])) {
1560         v = (VariantClass) i;
1561         found = TRUE;
1562         break;
1563       }
1564     }
1565
1566     if (!found) {
1567       if ((StrCaseStr(e, "fischer") && StrCaseStr(e, "random"))
1568           || StrCaseStr(e, "wild/fr")
1569           || StrCaseStr(e, "frc") || StrCaseStr(e, "960")) {
1570         v = VariantFischeRandom;
1571       } else if ((i = 4, p = StrCaseStr(e, "wild")) ||
1572                  (i = 1, p = StrCaseStr(e, "w"))) {
1573         p += i;
1574         while (*p && (isspace(*p) || *p == '(' || *p == '/')) p++;
1575         if (isdigit(*p)) {
1576           wnum = atoi(p);
1577         } else {
1578           wnum = -1;
1579         }
1580         switch (wnum) {
1581         case 0: /* FICS only, actually */
1582         case 1:
1583           /* Castling legal even if K starts on d-file */
1584           v = VariantWildCastle;
1585           break;
1586         case 2:
1587         case 3:
1588         case 4:
1589           /* Castling illegal even if K & R happen to start in
1590              normal positions. */
1591           v = VariantNoCastle;
1592           break;
1593         case 5:
1594         case 7:
1595         case 8:
1596         case 10:
1597         case 11:
1598         case 12:
1599         case 13:
1600         case 14:
1601         case 15:
1602         case 18:
1603         case 19:
1604           /* Castling legal iff K & R start in normal positions */
1605           v = VariantNormal;
1606           break;
1607         case 6:
1608         case 20:
1609         case 21:
1610           /* Special wilds for position setup; unclear what to do here */
1611           v = VariantLoadable;
1612           break;
1613         case 9:
1614           /* Bizarre ICC game */
1615           v = VariantTwoKings;
1616           break;
1617         case 16:
1618           v = VariantKriegspiel;
1619           break;
1620         case 17:
1621           v = VariantLosers;
1622           break;
1623         case 22:
1624           v = VariantFischeRandom;
1625           break;
1626         case 23:
1627           v = VariantCrazyhouse;
1628           break;
1629         case 24:
1630           v = VariantBughouse;
1631           break;
1632         case 25:
1633           v = Variant3Check;
1634           break;
1635         case 26:
1636           /* Not quite the same as FICS suicide! */
1637           v = VariantGiveaway;
1638           break;
1639         case 27:
1640           v = VariantAtomic;
1641           break;
1642         case 28:
1643           v = VariantShatranj;
1644           break;
1645
1646         /* Temporary names for future ICC types.  The name *will* change in
1647            the next xboard/WinBoard release after ICC defines it. */
1648         case 29:
1649           v = Variant29;
1650           break;
1651         case 30:
1652           v = Variant30;
1653           break;
1654         case 31:
1655           v = Variant31;
1656           break;
1657         case 32:
1658           v = Variant32;
1659           break;
1660         case 33:
1661           v = Variant33;
1662           break;
1663         case 34:
1664           v = Variant34;
1665           break;
1666         case 35:
1667           v = Variant35;
1668           break;
1669         case 36:
1670           v = Variant36;
1671           break;
1672         case 37:
1673           v = VariantShogi;
1674           break;
1675         case 38:
1676           v = VariantXiangqi;
1677           break;
1678         case 39:
1679           v = VariantCourier;
1680           break;
1681         case 40:
1682           v = VariantGothic;
1683           break;
1684         case 41:
1685           v = VariantCapablanca;
1686           break;
1687         case 42:
1688           v = VariantKnightmate;
1689           break;
1690         case 43:
1691           v = VariantFairy;
1692           break;
1693         case 44:
1694           v = VariantCylinder;
1695           break;
1696         case 45:
1697           v = VariantFalcon;
1698           break;
1699         case 46:
1700           v = VariantCapaRandom;
1701           break;
1702         case 47:
1703           v = VariantBerolina;
1704           break;
1705         case 48:
1706           v = VariantJanus;
1707           break;
1708         case 49:
1709           v = VariantSuper;
1710           break;
1711         case 50:
1712           v = VariantGreat;
1713           break;
1714         case -1:
1715           /* Found "wild" or "w" in the string but no number;
1716              must assume it's normal chess. */
1717           v = VariantNormal;
1718           break;
1719         default:
1720           sprintf(buf, _("Unknown wild type %d"), wnum);
1721           DisplayError(buf, 0);
1722           v = VariantUnknown;
1723           break;
1724         }
1725       }
1726     }
1727     if (appData.debugMode) {
1728       fprintf(debugFP, _("recognized '%s' (%d) as variant %s\n"),
1729               e, wnum, VariantName(v));
1730     }
1731     return v;
1732 }
1733
1734 static int leftover_start = 0, leftover_len = 0;
1735 char star_match[STAR_MATCH_N][MSG_SIZ];
1736
1737 /* Test whether pattern is present at &buf[*index]; if so, return TRUE,
1738    advance *index beyond it, and set leftover_start to the new value of
1739    *index; else return FALSE.  If pattern contains the character '*', it
1740    matches any sequence of characters not containing '\r', '\n', or the
1741    character following the '*' (if any), and the matched sequence(s) are
1742    copied into star_match.
1743    */
1744 int
1745 looking_at(buf, index, pattern)
1746      char *buf;
1747      int *index;
1748      char *pattern;
1749 {
1750     char *bufp = &buf[*index], *patternp = pattern;
1751     int star_count = 0;
1752     char *matchp = star_match[0];
1753
1754     for (;;) {
1755         if (*patternp == NULLCHAR) {
1756             *index = leftover_start = bufp - buf;
1757             *matchp = NULLCHAR;
1758             return TRUE;
1759         }
1760         if (*bufp == NULLCHAR) return FALSE;
1761         if (*patternp == '*') {
1762             if (*bufp == *(patternp + 1)) {
1763                 *matchp = NULLCHAR;
1764                 matchp = star_match[++star_count];
1765                 patternp += 2;
1766                 bufp++;
1767                 continue;
1768             } else if (*bufp == '\n' || *bufp == '\r') {
1769                 patternp++;
1770                 if (*patternp == NULLCHAR)
1771                   continue;
1772                 else
1773                   return FALSE;
1774             } else {
1775                 *matchp++ = *bufp++;
1776                 continue;
1777             }
1778         }
1779         if (*patternp != *bufp) return FALSE;
1780         patternp++;
1781         bufp++;
1782     }
1783 }
1784
1785 void
1786 SendToPlayer(data, length)
1787      char *data;
1788      int length;
1789 {
1790     int error, outCount;
1791     outCount = OutputToProcess(NoProc, data, length, &error);
1792     if (outCount < length) {
1793         DisplayFatalError(_("Error writing to display"), error, 1);
1794     }
1795 }
1796
1797 void
1798 PackHolding(packed, holding)
1799      char packed[];
1800      char *holding;
1801 {
1802     char *p = holding;
1803     char *q = packed;
1804     int runlength = 0;
1805     int curr = 9999;
1806     do {
1807         if (*p == curr) {
1808             runlength++;
1809         } else {
1810             switch (runlength) {
1811               case 0:
1812                 break;
1813               case 1:
1814                 *q++ = curr;
1815                 break;
1816               case 2:
1817                 *q++ = curr;
1818                 *q++ = curr;
1819                 break;
1820               default:
1821                 sprintf(q, "%d", runlength);
1822                 while (*q) q++;
1823                 *q++ = curr;
1824                 break;
1825             }
1826             runlength = 1;
1827             curr = *p;
1828         }
1829     } while (*p++);
1830     *q = NULLCHAR;
1831 }
1832
1833 /* Telnet protocol requests from the front end */
1834 void
1835 TelnetRequest(ddww, option)
1836      unsigned char ddww, option;
1837 {
1838     unsigned char msg[3];
1839     int outCount, outError;
1840
1841     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet) return;
1842
1843     if (appData.debugMode) {
1844         char buf1[8], buf2[8], *ddwwStr, *optionStr;
1845         switch (ddww) {
1846           case TN_DO:
1847             ddwwStr = "DO";
1848             break;
1849           case TN_DONT:
1850             ddwwStr = "DONT";
1851             break;
1852           case TN_WILL:
1853             ddwwStr = "WILL";
1854             break;
1855           case TN_WONT:
1856             ddwwStr = "WONT";
1857             break;
1858           default:
1859             ddwwStr = buf1;
1860             sprintf(buf1, "%d", ddww);
1861             break;
1862         }
1863         switch (option) {
1864           case TN_ECHO:
1865             optionStr = "ECHO";
1866             break;
1867           default:
1868             optionStr = buf2;
1869             sprintf(buf2, "%d", option);
1870             break;
1871         }
1872         fprintf(debugFP, ">%s %s ", ddwwStr, optionStr);
1873     }
1874     msg[0] = TN_IAC;
1875     msg[1] = ddww;
1876     msg[2] = option;
1877     outCount = OutputToProcess(icsPR, (char *)msg, 3, &outError);
1878     if (outCount < 3) {
1879         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1880     }
1881 }
1882
1883 void
1884 DoEcho()
1885 {
1886     if (!appData.icsActive) return;
1887     TelnetRequest(TN_DO, TN_ECHO);
1888 }
1889
1890 void
1891 DontEcho()
1892 {
1893     if (!appData.icsActive) return;
1894     TelnetRequest(TN_DONT, TN_ECHO);
1895 }
1896
1897 void
1898 CopyHoldings(Board board, char *holdings, ChessSquare lowestPiece)
1899 {
1900     /* put the holdings sent to us by the server on the board holdings area */
1901     int i, j, holdingsColumn, holdingsStartRow, direction, countsColumn;
1902     char p;
1903     ChessSquare piece;
1904
1905     if(gameInfo.holdingsWidth < 2)  return;
1906
1907     if( (int)lowestPiece >= BlackPawn ) {
1908         holdingsColumn = 0;
1909         countsColumn = 1;
1910         holdingsStartRow = BOARD_HEIGHT-1;
1911         direction = -1;
1912     } else {
1913         holdingsColumn = BOARD_WIDTH-1;
1914         countsColumn = BOARD_WIDTH-2;
1915         holdingsStartRow = 0;
1916         direction = 1;
1917     }
1918
1919     for(i=0; i<BOARD_HEIGHT; i++) { /* clear holdings */
1920         board[i][holdingsColumn] = EmptySquare;
1921         board[i][countsColumn]   = (ChessSquare) 0;
1922     }
1923     while( (p=*holdings++) != NULLCHAR ) {
1924         piece = CharToPiece( ToUpper(p) );
1925         if(piece == EmptySquare) continue;
1926         /*j = (int) piece - (int) WhitePawn;*/
1927         j = PieceToNumber(piece);
1928         if(j >= gameInfo.holdingsSize) continue; /* ignore pieces that do not fit */
1929         if(j < 0) continue;               /* should not happen */
1930         piece = (ChessSquare) ( (int)piece + (int)lowestPiece );
1931         board[holdingsStartRow+j*direction][holdingsColumn] = piece;
1932         board[holdingsStartRow+j*direction][countsColumn]++;
1933     }
1934
1935 }
1936
1937
1938 void
1939 VariantSwitch(Board board, VariantClass newVariant)
1940 {
1941    int newHoldingsWidth, newWidth = 8, newHeight = 8, i, j;
1942
1943    startedFromPositionFile = FALSE;
1944    if(gameInfo.variant == newVariant) return;
1945
1946    /* [HGM] This routine is called each time an assignment is made to
1947     * gameInfo.variant during a game, to make sure the board sizes
1948     * are set to match the new variant. If that means adding or deleting
1949     * holdings, we shift the playing board accordingly
1950     * This kludge is needed because in ICS observe mode, we get boards
1951     * of an ongoing game without knowing the variant, and learn about the
1952     * latter only later. This can be because of the move list we requested,
1953     * in which case the game history is refilled from the beginning anyway,
1954     * but also when receiving holdings of a crazyhouse game. In the latter
1955     * case we want to add those holdings to the already received position.
1956     */
1957
1958
1959    if (appData.debugMode) {
1960      fprintf(debugFP, "Switch board from %s to %s\n",
1961              VariantName(gameInfo.variant), VariantName(newVariant));
1962      setbuf(debugFP, NULL);
1963    }
1964    shuffleOpenings = 0;       /* [HGM] shuffle */
1965    gameInfo.holdingsSize = 5; /* [HGM] prepare holdings */
1966    switch(newVariant)
1967      {
1968      case VariantShogi:
1969        newWidth = 9;  newHeight = 9;
1970        gameInfo.holdingsSize = 7;
1971      case VariantBughouse:
1972      case VariantCrazyhouse:
1973        newHoldingsWidth = 2; break;
1974      case VariantGreat:
1975        newWidth = 10;
1976      case VariantSuper:
1977        newHoldingsWidth = 2;
1978        gameInfo.holdingsSize = 8;
1979        return;
1980      case VariantGothic:
1981      case VariantCapablanca:
1982      case VariantCapaRandom:
1983        newWidth = 10;
1984      default:
1985        newHoldingsWidth = gameInfo.holdingsSize = 0;
1986      };
1987
1988    if(newWidth  != gameInfo.boardWidth  ||
1989       newHeight != gameInfo.boardHeight ||
1990       newHoldingsWidth != gameInfo.holdingsWidth ) {
1991
1992      /* shift position to new playing area, if needed */
1993      if(newHoldingsWidth > gameInfo.holdingsWidth) {
1994        for(i=0; i<BOARD_HEIGHT; i++)
1995          for(j=BOARD_RGHT-1; j>=BOARD_LEFT; j--)
1996            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
1997              board[i][j];
1998        for(i=0; i<newHeight; i++) {
1999          board[i][0] = board[i][newWidth+2*newHoldingsWidth-1] = EmptySquare;
2000          board[i][1] = board[i][newWidth+2*newHoldingsWidth-2] = (ChessSquare) 0;
2001        }
2002      } else if(newHoldingsWidth < gameInfo.holdingsWidth) {
2003        for(i=0; i<BOARD_HEIGHT; i++)
2004          for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
2005            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2006              board[i][j];
2007      }
2008      gameInfo.boardWidth  = newWidth;
2009      gameInfo.boardHeight = newHeight;
2010      gameInfo.holdingsWidth = newHoldingsWidth;
2011      gameInfo.variant = newVariant;
2012      InitDrawingSizes(-2, 0);
2013      InitPosition(FALSE);          /* this sets up board[0], but also other stuff        */
2014    } else { gameInfo.variant = newVariant; InitPosition(FALSE); }
2015
2016    DrawPosition(TRUE, boards[currentMove]);
2017 }
2018
2019 static int loggedOn = FALSE;
2020
2021 /*-- Game start info cache: --*/
2022 int gs_gamenum;
2023 char gs_kind[MSG_SIZ];
2024 static char player1Name[128] = "";
2025 static char player2Name[128] = "";
2026 static int player1Rating = -1;
2027 static int player2Rating = -1;
2028 /*----------------------------*/
2029
2030 ColorClass curColor = ColorNormal;
2031 int suppressKibitz = 0;
2032
2033 void
2034 read_from_ics(isr, closure, data, count, error)
2035      InputSourceRef isr;
2036      VOIDSTAR closure;
2037      char *data;
2038      int count;
2039      int error;
2040 {
2041 #define BUF_SIZE 8192
2042 #define STARTED_NONE 0
2043 #define STARTED_MOVES 1
2044 #define STARTED_BOARD 2
2045 #define STARTED_OBSERVE 3
2046 #define STARTED_HOLDINGS 4
2047 #define STARTED_CHATTER 5
2048 #define STARTED_COMMENT 6
2049 #define STARTED_MOVES_NOHIDE 7
2050
2051     static int started = STARTED_NONE;
2052     static char parse[20000];
2053     static int parse_pos = 0;
2054     static char buf[BUF_SIZE + 1];
2055     static int firstTime = TRUE, intfSet = FALSE;
2056     static ColorClass prevColor = ColorNormal;
2057     static int savingComment = FALSE;
2058     char str[500];
2059     int i, oldi;
2060     int buf_len;
2061     int next_out;
2062     int tkind;
2063     int backup;    /* [DM] For zippy color lines */
2064     char *p;
2065     char talker[MSG_SIZ]; // [HGM] chat
2066     int channel;
2067
2068     if (appData.debugMode) {
2069       if (!error) {
2070         fprintf(debugFP, "<ICS: ");
2071         show_bytes(debugFP, data, count);
2072         fprintf(debugFP, "\n");
2073       }
2074     }
2075
2076     if (appData.debugMode) { int f = forwardMostMove;
2077         fprintf(debugFP, "ics input %d, castling = %d %d %d %d %d %d\n", f,
2078                 castlingRights[f][0],castlingRights[f][1],castlingRights[f][2],castlingRights[f][3],castlingRights[f][4],castlingRights[f][5]);
2079     }
2080     if (count > 0) {
2081         /* If last read ended with a partial line that we couldn't parse,
2082            prepend it to the new read and try again. */
2083         if (leftover_len > 0) {
2084             for (i=0; i<leftover_len; i++)
2085               buf[i] = buf[leftover_start + i];
2086         }
2087
2088         /* Copy in new characters, removing nulls and \r's */
2089         buf_len = leftover_len;
2090         for (i = 0; i < count; i++) {
2091             if (data[i] != NULLCHAR && data[i] != '\r')
2092               buf[buf_len++] = data[i];
2093             if(!appData.noJoin && buf_len >= 5 && buf[buf_len-5]=='\n' && buf[buf_len-4]=='\\' &&
2094                                buf[buf_len-3]==' '  && buf[buf_len-2]==' '  && buf[buf_len-1]==' ') {
2095                 buf_len -= 5; // [HGM] ICS: join continuation line of Lasker 2.2.3 server with previous
2096                 if(buf_len == 0 || buf[buf_len-1] != ' ')
2097                    buf[buf_len++] = ' '; // add space (assumes ICS does not break lines within word)
2098             }
2099         }
2100
2101         buf[buf_len] = NULLCHAR;
2102         next_out = leftover_len;
2103         leftover_start = 0;
2104
2105         i = 0;
2106         while (i < buf_len) {
2107             /* Deal with part of the TELNET option negotiation
2108                protocol.  We refuse to do anything beyond the
2109                defaults, except that we allow the WILL ECHO option,
2110                which ICS uses to turn off password echoing when we are
2111                directly connected to it.  We reject this option
2112                if localLineEditing mode is on (always on in xboard)
2113                and we are talking to port 23, which might be a real
2114                telnet server that will try to keep WILL ECHO on permanently.
2115              */
2116             if (buf_len - i >= 3 && (unsigned char) buf[i] == TN_IAC) {
2117                 static int remoteEchoOption = FALSE; /* telnet ECHO option */
2118                 unsigned char option;
2119                 oldi = i;
2120                 switch ((unsigned char) buf[++i]) {
2121                   case TN_WILL:
2122                     if (appData.debugMode)
2123                       fprintf(debugFP, "\n<WILL ");
2124                     switch (option = (unsigned char) buf[++i]) {
2125                       case TN_ECHO:
2126                         if (appData.debugMode)
2127                           fprintf(debugFP, "ECHO ");
2128                         /* Reply only if this is a change, according
2129                            to the protocol rules. */
2130                         if (remoteEchoOption) break;
2131                         if (appData.localLineEditing &&
2132                             atoi(appData.icsPort) == TN_PORT) {
2133                             TelnetRequest(TN_DONT, TN_ECHO);
2134                         } else {
2135                             EchoOff();
2136                             TelnetRequest(TN_DO, TN_ECHO);
2137                             remoteEchoOption = TRUE;
2138                         }
2139                         break;
2140                       default:
2141                         if (appData.debugMode)
2142                           fprintf(debugFP, "%d ", option);
2143                         /* Whatever this is, we don't want it. */
2144                         TelnetRequest(TN_DONT, option);
2145                         break;
2146                     }
2147                     break;
2148                   case TN_WONT:
2149                     if (appData.debugMode)
2150                       fprintf(debugFP, "\n<WONT ");
2151                     switch (option = (unsigned char) buf[++i]) {
2152                       case TN_ECHO:
2153                         if (appData.debugMode)
2154                           fprintf(debugFP, "ECHO ");
2155                         /* Reply only if this is a change, according
2156                            to the protocol rules. */
2157                         if (!remoteEchoOption) break;
2158                         EchoOn();
2159                         TelnetRequest(TN_DONT, TN_ECHO);
2160                         remoteEchoOption = FALSE;
2161                         break;
2162                       default:
2163                         if (appData.debugMode)
2164                           fprintf(debugFP, "%d ", (unsigned char) option);
2165                         /* Whatever this is, it must already be turned
2166                            off, because we never agree to turn on
2167                            anything non-default, so according to the
2168                            protocol rules, we don't reply. */
2169                         break;
2170                     }
2171                     break;
2172                   case TN_DO:
2173                     if (appData.debugMode)
2174                       fprintf(debugFP, "\n<DO ");
2175                     switch (option = (unsigned char) buf[++i]) {
2176                       default:
2177                         /* Whatever this is, we refuse to do it. */
2178                         if (appData.debugMode)
2179                           fprintf(debugFP, "%d ", option);
2180                         TelnetRequest(TN_WONT, option);
2181                         break;
2182                     }
2183                     break;
2184                   case TN_DONT:
2185                     if (appData.debugMode)
2186                       fprintf(debugFP, "\n<DONT ");
2187                     switch (option = (unsigned char) buf[++i]) {
2188                       default:
2189                         if (appData.debugMode)
2190                           fprintf(debugFP, "%d ", option);
2191                         /* Whatever this is, we are already not doing
2192                            it, because we never agree to do anything
2193                            non-default, so according to the protocol
2194                            rules, we don't reply. */
2195                         break;
2196                     }
2197                     break;
2198                   case TN_IAC:
2199                     if (appData.debugMode)
2200                       fprintf(debugFP, "\n<IAC ");
2201                     /* Doubled IAC; pass it through */
2202                     i--;
2203                     break;
2204                   default:
2205                     if (appData.debugMode)
2206                       fprintf(debugFP, "\n<%d ", (unsigned char) buf[i]);
2207                     /* Drop all other telnet commands on the floor */
2208                     break;
2209                 }
2210                 if (oldi > next_out)
2211                   SendToPlayer(&buf[next_out], oldi - next_out);
2212                 if (++i > next_out)
2213                   next_out = i;
2214                 continue;
2215             }
2216
2217             /* OK, this at least will *usually* work */
2218             if (!loggedOn && looking_at(buf, &i, "ics%")) {
2219                 loggedOn = TRUE;
2220             }
2221
2222             if (loggedOn && !intfSet) {
2223                 if (ics_type == ICS_ICC) {
2224                   sprintf(str,
2225                           "/set-quietly interface %s\n/set-quietly style 12\n",
2226                           programVersion);
2227           if (!appData.noJoin)
2228               strcat(str, "/set-quietly wrap 0\n");
2229                 } else if (ics_type == ICS_CHESSNET) {
2230                   sprintf(str, "/style 12\n");
2231                 } else {
2232                   strcpy(str, "alias $ @\n$set interface ");
2233                   strcat(str, programVersion);
2234                   strcat(str, "\n$iset startpos 1\n$iset ms 1\n");
2235 #ifdef WIN32
2236                   strcat(str, "$iset nohighlight 1\n");
2237 #endif
2238           if (!appData.noJoin)
2239               strcat(str, "$iset nowrap 1\n");
2240                   strcat(str, "$iset lock 1\n$style 12\n");
2241                 }
2242                 SendToICS(str);
2243                 NotifyFrontendLogin();
2244                 intfSet = TRUE;
2245             }
2246
2247             if (started == STARTED_COMMENT) {
2248                 /* Accumulate characters in comment */
2249                 parse[parse_pos++] = buf[i];
2250                 if (buf[i] == '\n') {
2251                     parse[parse_pos] = NULLCHAR;
2252                     if(chattingPartner>=0) {
2253                         char mess[MSG_SIZ];
2254                         sprintf(mess, "%s%s", talker, parse);
2255                         OutputChatMessage(chattingPartner, mess);
2256                         chattingPartner = -1;
2257                     } else
2258                     if(!suppressKibitz) // [HGM] kibitz
2259                         AppendComment(forwardMostMove, StripHighlight(parse));
2260                     else { // [HGM kibitz: divert memorized engine kibitz to engine-output window
2261                         int nrDigit = 0, nrAlph = 0, i;
2262                         if(parse_pos > MSG_SIZ - 30) // defuse unreasonably long input
2263                         { parse_pos = MSG_SIZ-30; parse[parse_pos - 1] = '\n'; }
2264                         parse[parse_pos] = NULLCHAR;
2265                         // try to be smart: if it does not look like search info, it should go to
2266                         // ICS interaction window after all, not to engine-output window.
2267                         for(i=0; i<parse_pos; i++) { // count letters and digits
2268                             nrDigit += (parse[i] >= '0' && parse[i] <= '9');
2269                             nrAlph  += (parse[i] >= 'a' && parse[i] <= 'z');
2270                             nrAlph  += (parse[i] >= 'A' && parse[i] <= 'Z');
2271                         }
2272                         if(nrAlph < 9*nrDigit) { // if more than 10% digit we assume search info
2273                             int depth=0; float score;
2274                             if(sscanf(parse, "!!! %f/%d", &score, &depth) == 2 && depth>0) {
2275                                 // [HGM] kibitz: save kibitzed opponent info for PGN and eval graph
2276                                 pvInfoList[forwardMostMove-1].depth = depth;
2277                                 pvInfoList[forwardMostMove-1].score = 100*score;
2278                             }
2279                             OutputKibitz(suppressKibitz, parse);
2280                         } else {
2281                             char tmp[MSG_SIZ];
2282                             sprintf(tmp, _("your opponent kibitzes: %s"), parse);
2283                             SendToPlayer(tmp, strlen(tmp));
2284                         }
2285                     }
2286                     started = STARTED_NONE;
2287                 } else {
2288                     /* Don't match patterns against characters in chatter */
2289                     i++;
2290                     continue;
2291                 }
2292             }
2293             if (started == STARTED_CHATTER) {
2294                 if (buf[i] != '\n') {
2295                     /* Don't match patterns against characters in chatter */
2296                     i++;
2297                     continue;
2298                 }
2299                 started = STARTED_NONE;
2300             }
2301
2302             /* Kludge to deal with rcmd protocol */
2303             if (firstTime && looking_at(buf, &i, "\001*")) {
2304                 DisplayFatalError(&buf[1], 0, 1);
2305                 continue;
2306             } else {
2307                 firstTime = FALSE;
2308             }
2309
2310             if (!loggedOn && looking_at(buf, &i, "chessclub.com")) {
2311                 ics_type = ICS_ICC;
2312                 ics_prefix = "/";
2313                 if (appData.debugMode)
2314                   fprintf(debugFP, "ics_type %d\n", ics_type);
2315                 continue;
2316             }
2317             if (!loggedOn && looking_at(buf, &i, "freechess.org")) {
2318                 ics_type = ICS_FICS;
2319                 ics_prefix = "$";
2320                 if (appData.debugMode)
2321                   fprintf(debugFP, "ics_type %d\n", ics_type);
2322                 continue;
2323             }
2324             if (!loggedOn && looking_at(buf, &i, "chess.net")) {
2325                 ics_type = ICS_CHESSNET;
2326                 ics_prefix = "/";
2327                 if (appData.debugMode)
2328                   fprintf(debugFP, "ics_type %d\n", ics_type);
2329                 continue;
2330             }
2331
2332             if (!loggedOn &&
2333                 (looking_at(buf, &i, "\"*\" is *a registered name") ||
2334                  looking_at(buf, &i, "Logging you in as \"*\"") ||
2335                  looking_at(buf, &i, "will be \"*\""))) {
2336               strcpy(ics_handle, star_match[0]);
2337               continue;
2338             }
2339
2340             if (loggedOn && !have_set_title && ics_handle[0] != NULLCHAR) {
2341               char buf[MSG_SIZ];
2342               snprintf(buf, sizeof(buf), "%s@%s", ics_handle, appData.icsHost);
2343               DisplayIcsInteractionTitle(buf);
2344               have_set_title = TRUE;
2345             }
2346
2347             /* skip finger notes */
2348             if (started == STARTED_NONE &&
2349                 ((buf[i] == ' ' && isdigit(buf[i+1])) ||
2350                  (buf[i] == '1' && buf[i+1] == '0')) &&
2351                 buf[i+2] == ':' && buf[i+3] == ' ') {
2352               started = STARTED_CHATTER;
2353               i += 3;
2354               continue;
2355             }
2356
2357             /* skip formula vars */
2358             if (started == STARTED_NONE &&
2359                 buf[i] == 'f' && isdigit(buf[i+1]) && buf[i+2] == ':') {
2360               started = STARTED_CHATTER;
2361               i += 3;
2362               continue;
2363             }
2364
2365             oldi = i;
2366             // [HGM] kibitz: try to recognize opponent engine-score kibitzes, to divert them to engine-output window
2367             if (appData.autoKibitz && started == STARTED_NONE &&
2368                 !appData.icsEngineAnalyze &&                     // [HGM] [DM] ICS analyze
2369                 (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack || gameMode == IcsObserving)) {
2370                 if(looking_at(buf, &i, "* kibitzes: ") &&
2371                    (StrStr(star_match[0], gameInfo.white) == star_match[0] ||
2372                     StrStr(star_match[0], gameInfo.black) == star_match[0]   )) { // kibitz of self or opponent
2373                         suppressKibitz = TRUE;
2374                         if((StrStr(star_match[0], gameInfo.white) == star_match[0]
2375                                 && (gameMode == IcsPlayingWhite)) ||
2376                            (StrStr(star_match[0], gameInfo.black) == star_match[0]
2377                                 && (gameMode == IcsPlayingBlack))   ) // opponent kibitz
2378                             started = STARTED_CHATTER; // own kibitz we simply discard
2379                         else {
2380                             started = STARTED_COMMENT; // make sure it will be collected in parse[]
2381                             parse_pos = 0; parse[0] = NULLCHAR;
2382                             savingComment = TRUE;
2383                             suppressKibitz = gameMode != IcsObserving ? 2 :
2384                                 (StrStr(star_match[0], gameInfo.white) == NULL) + 1;
2385                         }
2386                         continue;
2387                 } else
2388                 if(looking_at(buf, &i, "kibitzed to")) { // suppress the acknowledgements of our own autoKibitz
2389                     started = STARTED_CHATTER;
2390                     suppressKibitz = TRUE;
2391                 }
2392             } // [HGM] kibitz: end of patch
2393
2394 //if(appData.debugMode) fprintf(debugFP, "hunt for tell, buf = %s\n", buf+i);
2395
2396             // [HGM] chat: intercept tells by users for which we have an open chat window
2397             channel = -1;
2398             if(started == STARTED_NONE && (looking_at(buf, &i, "* tells you:") || looking_at(buf, &i, "* says:") ||
2399                                            looking_at(buf, &i, "* whispers:") ||
2400                                            looking_at(buf, &i, "*(*):") && (sscanf(star_match[1], "%d", &channel),1) ||
2401                                            looking_at(buf, &i, "*(*)(*):") && sscanf(star_match[2], "%d", &channel) == 1 )) {
2402                 int p;
2403                 sscanf(star_match[0], "%[^(]", talker+1); // strip (C) or (U) off ICS handle
2404                 chattingPartner = -1;
2405
2406                 if(channel >= 0) // channel broadcast; look if there is a chatbox for this channel
2407                 for(p=0; p<MAX_CHAT; p++) {
2408                     if(channel == atoi(chatPartner[p])) {
2409                     talker[0] = '['; strcat(talker, "]");
2410                     chattingPartner = p; break;
2411                     }
2412                 } else
2413                 if(buf[i-3] == 'r') // whisper; look if there is a WHISPER chatbox
2414                 for(p=0; p<MAX_CHAT; p++) {
2415                     if(!strcmp("WHISPER", chatPartner[p])) {
2416                         talker[0] = '['; strcat(talker, "]");
2417                         chattingPartner = p; break;
2418                     }
2419                 }
2420                 if(chattingPartner<0) // if not, look if there is a chatbox for this indivdual
2421                 for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
2422                     talker[0] = 0;
2423                     chattingPartner = p; break;
2424                 }
2425                 if(chattingPartner<0) i = oldi; else {
2426                     started = STARTED_COMMENT;
2427                     parse_pos = 0; parse[0] = NULLCHAR;
2428                     savingComment = TRUE;
2429                     suppressKibitz = TRUE;
2430                 }
2431             } // [HGM] chat: end of patch
2432
2433             if (appData.zippyTalk || appData.zippyPlay) {
2434                 /* [DM] Backup address for color zippy lines */
2435                 backup = i;
2436 #if ZIPPY
2437        #ifdef WIN32
2438                if (loggedOn == TRUE)
2439                        if (ZippyControl(buf, &backup) || ZippyConverse(buf, &backup) ||
2440                           (appData.zippyPlay && ZippyMatch(buf, &backup)));
2441        #else
2442                 if (ZippyControl(buf, &i) ||
2443                     ZippyConverse(buf, &i) ||
2444                     (appData.zippyPlay && ZippyMatch(buf, &i))) {
2445                       loggedOn = TRUE;
2446                       if (!appData.colorize) continue;
2447                 }
2448        #endif
2449 #endif
2450             } // [DM] 'else { ' deleted
2451                 if (
2452                     /* Regular tells and says */
2453                     (tkind = 1, looking_at(buf, &i, "* tells you: ")) ||
2454                     looking_at(buf, &i, "* (your partner) tells you: ") ||
2455                     looking_at(buf, &i, "* says: ") ||
2456                     /* Don't color "message" or "messages" output */
2457                     (tkind = 5, looking_at(buf, &i, "*. * (*:*): ")) ||
2458                     looking_at(buf, &i, "*. * at *:*: ") ||
2459                     looking_at(buf, &i, "--* (*:*): ") ||
2460                     /* Message notifications (same color as tells) */
2461                     looking_at(buf, &i, "* has left a message ") ||
2462                     looking_at(buf, &i, "* just sent you a message:\n") ||
2463                     /* Whispers and kibitzes */
2464                     (tkind = 2, looking_at(buf, &i, "* whispers: ")) ||
2465                     looking_at(buf, &i, "* kibitzes: ") ||
2466                     /* Channel tells */
2467                     (tkind = 3, looking_at(buf, &i, "*(*: "))) {
2468
2469                   if (tkind == 1 && strchr(star_match[0], ':')) {
2470                       /* Avoid "tells you:" spoofs in channels */
2471                      tkind = 3;
2472                   }
2473                   if (star_match[0][0] == NULLCHAR ||
2474                       strchr(star_match[0], ' ') ||
2475                       (tkind == 3 && strchr(star_match[1], ' '))) {
2476                     /* Reject bogus matches */
2477                     i = oldi;
2478                   } else {
2479                     if (appData.colorize) {
2480                       if (oldi > next_out) {
2481                         SendToPlayer(&buf[next_out], oldi - next_out);
2482                         next_out = oldi;
2483                       }
2484                       switch (tkind) {
2485                       case 1:
2486                         Colorize(ColorTell, FALSE);
2487                         curColor = ColorTell;
2488                         break;
2489                       case 2:
2490                         Colorize(ColorKibitz, FALSE);
2491                         curColor = ColorKibitz;
2492                         break;
2493                       case 3:
2494                         p = strrchr(star_match[1], '(');
2495                         if (p == NULL) {
2496                           p = star_match[1];
2497                         } else {
2498                           p++;
2499                         }
2500                         if (atoi(p) == 1) {
2501                           Colorize(ColorChannel1, FALSE);
2502                           curColor = ColorChannel1;
2503                         } else {
2504                           Colorize(ColorChannel, FALSE);
2505                           curColor = ColorChannel;
2506                         }
2507                         break;
2508                       case 5:
2509                         curColor = ColorNormal;
2510                         break;
2511                       }
2512                     }
2513                     if (started == STARTED_NONE && appData.autoComment &&
2514                         (gameMode == IcsObserving ||
2515                          gameMode == IcsPlayingWhite ||
2516                          gameMode == IcsPlayingBlack)) {
2517                       parse_pos = i - oldi;
2518                       memcpy(parse, &buf[oldi], parse_pos);
2519                       parse[parse_pos] = NULLCHAR;
2520                       started = STARTED_COMMENT;
2521                       savingComment = TRUE;
2522                     } else {
2523                       started = STARTED_CHATTER;
2524                       savingComment = FALSE;
2525                     }
2526                     loggedOn = TRUE;
2527                     continue;
2528                   }
2529                 }
2530
2531                 if (looking_at(buf, &i, "* s-shouts: ") ||
2532                     looking_at(buf, &i, "* c-shouts: ")) {
2533                     if (appData.colorize) {
2534                         if (oldi > next_out) {
2535                             SendToPlayer(&buf[next_out], oldi - next_out);
2536                             next_out = oldi;
2537                         }
2538                         Colorize(ColorSShout, FALSE);
2539                         curColor = ColorSShout;
2540                     }
2541                     loggedOn = TRUE;
2542                     started = STARTED_CHATTER;
2543                     continue;
2544                 }
2545
2546                 if (looking_at(buf, &i, "--->")) {
2547                     loggedOn = TRUE;
2548                     continue;
2549                 }
2550
2551                 if (looking_at(buf, &i, "* shouts: ") ||
2552                     looking_at(buf, &i, "--> ")) {
2553                     if (appData.colorize) {
2554                         if (oldi > next_out) {
2555                             SendToPlayer(&buf[next_out], oldi - next_out);
2556                             next_out = oldi;
2557                         }
2558                         Colorize(ColorShout, FALSE);
2559                         curColor = ColorShout;
2560                     }
2561                     loggedOn = TRUE;
2562                     started = STARTED_CHATTER;
2563                     continue;
2564                 }
2565
2566                 if (looking_at( buf, &i, "Challenge:")) {
2567                     if (appData.colorize) {
2568                         if (oldi > next_out) {
2569                             SendToPlayer(&buf[next_out], oldi - next_out);
2570                             next_out = oldi;
2571                         }
2572                         Colorize(ColorChallenge, FALSE);
2573                         curColor = ColorChallenge;
2574                     }
2575                     loggedOn = TRUE;
2576                     continue;
2577                 }
2578
2579                 if (looking_at(buf, &i, "* offers you") ||
2580                     looking_at(buf, &i, "* offers to be") ||
2581                     looking_at(buf, &i, "* would like to") ||
2582                     looking_at(buf, &i, "* requests to") ||
2583                     looking_at(buf, &i, "Your opponent offers") ||
2584                     looking_at(buf, &i, "Your opponent requests")) {
2585
2586                     if (appData.colorize) {
2587                         if (oldi > next_out) {
2588                             SendToPlayer(&buf[next_out], oldi - next_out);
2589                             next_out = oldi;
2590                         }
2591                         Colorize(ColorRequest, FALSE);
2592                         curColor = ColorRequest;
2593                     }
2594                     continue;
2595                 }
2596
2597                 if (looking_at(buf, &i, "* (*) seeking")) {
2598                     if (appData.colorize) {
2599                         if (oldi > next_out) {
2600                             SendToPlayer(&buf[next_out], oldi - next_out);
2601                             next_out = oldi;
2602                         }
2603                         Colorize(ColorSeek, FALSE);
2604                         curColor = ColorSeek;
2605                     }
2606                     continue;
2607             }
2608
2609             if (looking_at(buf, &i, "\\   ")) {
2610                 if (prevColor != ColorNormal) {
2611                     if (oldi > next_out) {
2612                         SendToPlayer(&buf[next_out], oldi - next_out);
2613                         next_out = oldi;
2614                     }
2615                     Colorize(prevColor, TRUE);
2616                     curColor = prevColor;
2617                 }
2618                 if (savingComment) {
2619                     parse_pos = i - oldi;
2620                     memcpy(parse, &buf[oldi], parse_pos);
2621                     parse[parse_pos] = NULLCHAR;
2622                     started = STARTED_COMMENT;
2623                 } else {
2624                     started = STARTED_CHATTER;
2625                 }
2626                 continue;
2627             }
2628
2629             if (looking_at(buf, &i, "Black Strength :") ||
2630                 looking_at(buf, &i, "<<< style 10 board >>>") ||
2631                 looking_at(buf, &i, "<10>") ||
2632                 looking_at(buf, &i, "#@#")) {
2633                 /* Wrong board style */
2634                 loggedOn = TRUE;
2635                 SendToICS(ics_prefix);
2636                 SendToICS("set style 12\n");
2637                 SendToICS(ics_prefix);
2638                 SendToICS("refresh\n");
2639                 continue;
2640             }
2641
2642             if (!have_sent_ICS_logon && looking_at(buf, &i, "login:")) {
2643                 ICSInitScript();
2644                 have_sent_ICS_logon = 1;
2645                 continue;
2646             }
2647
2648             if (ics_getting_history != H_GETTING_MOVES /*smpos kludge*/ &&
2649                 (looking_at(buf, &i, "\n<12> ") ||
2650                  looking_at(buf, &i, "<12> "))) {
2651                 loggedOn = TRUE;
2652                 if (oldi > next_out) {
2653                     SendToPlayer(&buf[next_out], oldi - next_out);
2654                 }
2655                 next_out = i;
2656                 started = STARTED_BOARD;
2657                 parse_pos = 0;
2658                 continue;
2659             }
2660
2661             if ((started == STARTED_NONE && looking_at(buf, &i, "\n<b1> ")) ||
2662                 looking_at(buf, &i, "<b1> ")) {
2663                 if (oldi > next_out) {
2664                     SendToPlayer(&buf[next_out], oldi - next_out);
2665                 }
2666                 next_out = i;
2667                 started = STARTED_HOLDINGS;
2668                 parse_pos = 0;
2669                 continue;
2670             }
2671
2672             if (looking_at(buf, &i, "* *vs. * *--- *")) {
2673                 loggedOn = TRUE;
2674                 /* Header for a move list -- first line */
2675
2676                 switch (ics_getting_history) {
2677                   case H_FALSE:
2678                     switch (gameMode) {
2679                       case IcsIdle:
2680                       case BeginningOfGame:
2681                         /* User typed "moves" or "oldmoves" while we
2682                            were idle.  Pretend we asked for these
2683                            moves and soak them up so user can step
2684                            through them and/or save them.
2685                            */
2686                         Reset(FALSE, TRUE);
2687                         gameMode = IcsObserving;
2688                         ModeHighlight();
2689                         ics_gamenum = -1;
2690                         ics_getting_history = H_GOT_UNREQ_HEADER;
2691                         break;
2692                       case EditGame: /*?*/
2693                       case EditPosition: /*?*/
2694                         /* Should above feature work in these modes too? */
2695                         /* For now it doesn't */
2696                         ics_getting_history = H_GOT_UNWANTED_HEADER;
2697                         break;
2698                       default:
2699                         ics_getting_history = H_GOT_UNWANTED_HEADER;
2700                         break;
2701                     }
2702                     break;
2703                   case H_REQUESTED:
2704                     /* Is this the right one? */
2705                     if (gameInfo.white && gameInfo.black &&
2706                         strcmp(gameInfo.white, star_match[0]) == 0 &&
2707                         strcmp(gameInfo.black, star_match[2]) == 0) {
2708                         /* All is well */
2709                         ics_getting_history = H_GOT_REQ_HEADER;
2710                     }
2711                     break;
2712                   case H_GOT_REQ_HEADER:
2713                   case H_GOT_UNREQ_HEADER:
2714                   case H_GOT_UNWANTED_HEADER:
2715                   case H_GETTING_MOVES:
2716                     /* Should not happen */
2717                     DisplayError(_("Error gathering move list: two headers"), 0);
2718                     ics_getting_history = H_FALSE;
2719                     break;
2720                 }
2721
2722                 /* Save player ratings into gameInfo if needed */
2723                 if ((ics_getting_history == H_GOT_REQ_HEADER ||
2724                      ics_getting_history == H_GOT_UNREQ_HEADER) &&
2725                     (gameInfo.whiteRating == -1 ||
2726                      gameInfo.blackRating == -1)) {
2727
2728                     gameInfo.whiteRating = string_to_rating(star_match[1]);
2729                     gameInfo.blackRating = string_to_rating(star_match[3]);
2730                     if (appData.debugMode)
2731                       fprintf(debugFP, _("Ratings from header: W %d, B %d\n"),
2732                               gameInfo.whiteRating, gameInfo.blackRating);
2733                 }
2734                 continue;
2735             }
2736
2737             if (looking_at(buf, &i,
2738               "* * match, initial time: * minute*, increment: * second")) {
2739                 /* Header for a move list -- second line */
2740                 /* Initial board will follow if this is a wild game */
2741                 if (gameInfo.event != NULL) free(gameInfo.event);
2742                 sprintf(str, "ICS %s %s match", star_match[0], star_match[1]);
2743                 gameInfo.event = StrSave(str);
2744                 /* [HGM] we switched variant. Translate boards if needed. */
2745                 VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event));
2746                 continue;
2747             }
2748
2749             if (looking_at(buf, &i, "Move  ")) {
2750                 /* Beginning of a move list */
2751                 switch (ics_getting_history) {
2752                   case H_FALSE:
2753                     /* Normally should not happen */
2754                     /* Maybe user hit reset while we were parsing */
2755                     break;
2756                   case H_REQUESTED:
2757                     /* Happens if we are ignoring a move list that is not
2758                      * the one we just requested.  Common if the user
2759                      * tries to observe two games without turning off
2760                      * getMoveList */
2761                     break;
2762                   case H_GETTING_MOVES:
2763                     /* Should not happen */
2764                     DisplayError(_("Error gathering move list: nested"), 0);
2765                     ics_getting_history = H_FALSE;
2766                     break;
2767                   case H_GOT_REQ_HEADER:
2768                     ics_getting_history = H_GETTING_MOVES;
2769                     started = STARTED_MOVES;
2770                     parse_pos = 0;
2771                     if (oldi > next_out) {
2772                         SendToPlayer(&buf[next_out], oldi - next_out);
2773                     }
2774                     break;
2775                   case H_GOT_UNREQ_HEADER:
2776                     ics_getting_history = H_GETTING_MOVES;
2777                     started = STARTED_MOVES_NOHIDE;
2778                     parse_pos = 0;
2779                     break;
2780                   case H_GOT_UNWANTED_HEADER:
2781                     ics_getting_history = H_FALSE;
2782                     break;
2783                 }
2784                 continue;
2785             }
2786
2787             if (looking_at(buf, &i, "% ") ||
2788                 ((started == STARTED_MOVES || started == STARTED_MOVES_NOHIDE)
2789                  && looking_at(buf, &i, "}*"))) { char *bookHit = NULL; // [HGM] book
2790                 savingComment = FALSE;
2791                 switch (started) {
2792                   case STARTED_MOVES:
2793                   case STARTED_MOVES_NOHIDE:
2794                     memcpy(&parse[parse_pos], &buf[oldi], i - oldi);
2795                     parse[parse_pos + i - oldi] = NULLCHAR;
2796                     ParseGameHistory(parse);
2797 #if ZIPPY
2798                     if (appData.zippyPlay && first.initDone) {
2799                         FeedMovesToProgram(&first, forwardMostMove);
2800                         if (gameMode == IcsPlayingWhite) {
2801                             if (WhiteOnMove(forwardMostMove)) {
2802                                 if (first.sendTime) {
2803                                   if (first.useColors) {
2804                                     SendToProgram("black\n", &first);
2805                                   }
2806                                   SendTimeRemaining(&first, TRUE);
2807                                 }
2808                                 if (first.useColors) {
2809                                   SendToProgram("white\n", &first); // [HGM] book: made sending of "go\n" book dependent
2810                                 }
2811                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: probe book for initial pos
2812                                 first.maybeThinking = TRUE;
2813                             } else {
2814                                 if (first.usePlayother) {
2815                                   if (first.sendTime) {
2816                                     SendTimeRemaining(&first, TRUE);
2817                                   }
2818                                   SendToProgram("playother\n", &first);
2819                                   firstMove = FALSE;
2820                                 } else {
2821                                   firstMove = TRUE;
2822                                 }
2823                             }
2824                         } else if (gameMode == IcsPlayingBlack) {
2825                             if (!WhiteOnMove(forwardMostMove)) {
2826                                 if (first.sendTime) {
2827                                   if (first.useColors) {
2828                                     SendToProgram("white\n", &first);
2829                                   }
2830                                   SendTimeRemaining(&first, FALSE);
2831                                 }
2832                                 if (first.useColors) {
2833                                   SendToProgram("black\n", &first);
2834                                 }
2835                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE);
2836                                 first.maybeThinking = TRUE;
2837                             } else {
2838                                 if (first.usePlayother) {
2839                                   if (first.sendTime) {
2840                                     SendTimeRemaining(&first, FALSE);
2841                                   }
2842                                   SendToProgram("playother\n", &first);
2843                                   firstMove = FALSE;
2844                                 } else {
2845                                   firstMove = TRUE;
2846                                 }
2847                             }
2848                         }
2849                     }
2850 #endif
2851                     if (gameMode == IcsObserving && ics_gamenum == -1) {
2852                         /* Moves came from oldmoves or moves command
2853                            while we weren't doing anything else.
2854                            */
2855                         currentMove = forwardMostMove;
2856                         ClearHighlights();/*!!could figure this out*/
2857                         flipView = appData.flipView;
2858                         DrawPosition(FALSE, boards[currentMove]);
2859                         DisplayBothClocks();
2860                         sprintf(str, "%s vs. %s",
2861                                 gameInfo.white, gameInfo.black);
2862                         DisplayTitle(str);
2863                         gameMode = IcsIdle;
2864                     } else {
2865                         /* Moves were history of an active game */
2866                         if (gameInfo.resultDetails != NULL) {
2867                             free(gameInfo.resultDetails);
2868                             gameInfo.resultDetails = NULL;
2869                         }
2870                     }
2871                     HistorySet(parseList, backwardMostMove,
2872                                forwardMostMove, currentMove-1);
2873                     DisplayMove(currentMove - 1);
2874                     if (started == STARTED_MOVES) next_out = i;
2875                     started = STARTED_NONE;
2876                     ics_getting_history = H_FALSE;
2877                     break;
2878
2879                   case STARTED_OBSERVE:
2880                     started = STARTED_NONE;
2881                     SendToICS(ics_prefix);
2882                     SendToICS("refresh\n");
2883                     break;
2884
2885                   default:
2886                     break;
2887                 }
2888                 if(bookHit) { // [HGM] book: simulate book reply
2889                     static char bookMove[MSG_SIZ]; // a bit generous?
2890
2891                     programStats.nodes = programStats.depth = programStats.time =
2892                     programStats.score = programStats.got_only_move = 0;
2893                     sprintf(programStats.movelist, "%s (xbook)", bookHit);
2894
2895                     strcpy(bookMove, "move ");
2896                     strcat(bookMove, bookHit);
2897                     HandleMachineMove(bookMove, &first);
2898                 }
2899                 continue;
2900             }
2901
2902             if ((started == STARTED_MOVES || started == STARTED_BOARD ||
2903                  started == STARTED_HOLDINGS ||
2904                  started == STARTED_MOVES_NOHIDE) && i >= leftover_len) {
2905                 /* Accumulate characters in move list or board */
2906                 parse[parse_pos++] = buf[i];
2907             }
2908
2909             /* Start of game messages.  Mostly we detect start of game
2910                when the first board image arrives.  On some versions
2911                of the ICS, though, we need to do a "refresh" after starting
2912                to observe in order to get the current board right away. */
2913             if (looking_at(buf, &i, "Adding game * to observation list")) {
2914                 started = STARTED_OBSERVE;
2915                 continue;
2916             }
2917
2918             /* Handle auto-observe */
2919             if (appData.autoObserve &&
2920                 (gameMode == IcsIdle || gameMode == BeginningOfGame) &&
2921                 looking_at(buf, &i, "Game notification: * (*) vs. * (*)")) {
2922                 char *player;
2923                 /* Choose the player that was highlighted, if any. */
2924                 if (star_match[0][0] == '\033' ||
2925                     star_match[1][0] != '\033') {
2926                     player = star_match[0];
2927                 } else {
2928                     player = star_match[2];
2929                 }
2930                 sprintf(str, "%sobserve %s\n",
2931                         ics_prefix, StripHighlightAndTitle(player));
2932                 SendToICS(str);
2933
2934                 /* Save ratings from notify string */
2935                 strcpy(player1Name, star_match[0]);
2936                 player1Rating = string_to_rating(star_match[1]);
2937                 strcpy(player2Name, star_match[2]);
2938                 player2Rating = string_to_rating(star_match[3]);
2939
2940                 if (appData.debugMode)
2941                   fprintf(debugFP,
2942                           "Ratings from 'Game notification:' %s %d, %s %d\n",
2943                           player1Name, player1Rating,
2944                           player2Name, player2Rating);
2945
2946                 continue;
2947             }
2948
2949             /* Deal with automatic examine mode after a game,
2950                and with IcsObserving -> IcsExamining transition */
2951             if (looking_at(buf, &i, "Entering examine mode for game *") ||
2952                 looking_at(buf, &i, "has made you an examiner of game *")) {
2953
2954                 int gamenum = atoi(star_match[0]);
2955                 if ((gameMode == IcsIdle || gameMode == IcsObserving) &&
2956                     gamenum == ics_gamenum) {
2957                     /* We were already playing or observing this game;
2958                        no need to refetch history */
2959                     gameMode = IcsExamining;
2960                     if (pausing) {
2961                         pauseExamForwardMostMove = forwardMostMove;
2962                     } else if (currentMove < forwardMostMove) {
2963                         ForwardInner(forwardMostMove);
2964                     }
2965                 } else {
2966                     /* I don't think this case really can happen */
2967                     SendToICS(ics_prefix);
2968                     SendToICS("refresh\n");
2969                 }
2970                 continue;
2971             }
2972
2973             /* Error messages */
2974 //          if (ics_user_moved) {
2975             if (1) { // [HGM] old way ignored error after move type in; ics_user_moved is not set then!
2976                 if (looking_at(buf, &i, "Illegal move") ||
2977                     looking_at(buf, &i, "Not a legal move") ||
2978                     looking_at(buf, &i, "Your king is in check") ||
2979                     looking_at(buf, &i, "It isn't your turn") ||
2980                     looking_at(buf, &i, "It is not your move")) {
2981                     /* Illegal move */
2982                     if (ics_user_moved && forwardMostMove > backwardMostMove) { // only backup if we already moved
2983                         currentMove = --forwardMostMove;
2984                         DisplayMove(currentMove - 1); /* before DMError */
2985                         DrawPosition(FALSE, boards[currentMove]);
2986                         SwitchClocks();
2987                         DisplayBothClocks();
2988                     }
2989                     DisplayMoveError(_("Illegal move (rejected by ICS)")); // [HGM] but always relay error msg
2990                     ics_user_moved = 0;
2991                     continue;
2992                 }
2993             }
2994
2995             if (looking_at(buf, &i, "still have time") ||
2996                 looking_at(buf, &i, "not out of time") ||
2997                 looking_at(buf, &i, "either player is out of time") ||
2998                 looking_at(buf, &i, "has timeseal; checking")) {
2999                 /* We must have called his flag a little too soon */
3000                 whiteFlag = blackFlag = FALSE;
3001                 continue;
3002             }
3003
3004             if (looking_at(buf, &i, "added * seconds to") ||
3005                 looking_at(buf, &i, "seconds were added to")) {
3006                 /* Update the clocks */
3007                 SendToICS(ics_prefix);
3008                 SendToICS("refresh\n");
3009                 continue;
3010             }
3011
3012             if (!ics_clock_paused && looking_at(buf, &i, "clock paused")) {
3013                 ics_clock_paused = TRUE;
3014                 StopClocks();
3015                 continue;
3016             }
3017
3018             if (ics_clock_paused && looking_at(buf, &i, "clock resumed")) {
3019                 ics_clock_paused = FALSE;
3020                 StartClocks();
3021                 continue;
3022             }
3023
3024             /* Grab player ratings from the Creating: message.
3025                Note we have to check for the special case when
3026                the ICS inserts things like [white] or [black]. */
3027             if (looking_at(buf, &i, "Creating: * (*)* * (*)") ||
3028                 looking_at(buf, &i, "Creating: * (*) [*] * (*)")) {
3029                 /* star_matches:
3030                    0    player 1 name (not necessarily white)
3031                    1    player 1 rating
3032                    2    empty, white, or black (IGNORED)
3033                    3    player 2 name (not necessarily black)
3034                    4    player 2 rating
3035
3036                    The names/ratings are sorted out when the game
3037                    actually starts (below).
3038                 */
3039                 strcpy(player1Name, StripHighlightAndTitle(star_match[0]));
3040                 player1Rating = string_to_rating(star_match[1]);
3041                 strcpy(player2Name, StripHighlightAndTitle(star_match[3]));
3042                 player2Rating = string_to_rating(star_match[4]);
3043
3044                 if (appData.debugMode)
3045                   fprintf(debugFP,
3046                           "Ratings from 'Creating:' %s %d, %s %d\n",
3047                           player1Name, player1Rating,
3048                           player2Name, player2Rating);
3049
3050                 continue;
3051             }
3052
3053             /* Improved generic start/end-of-game messages */
3054             if ((tkind=0, looking_at(buf, &i, "{Game * (* vs. *) *}*")) ||
3055                 (tkind=1, looking_at(buf, &i, "{Game * (*(*) vs. *(*)) *}*"))){
3056                 /* If tkind == 0: */
3057                 /* star_match[0] is the game number */
3058                 /*           [1] is the white player's name */
3059                 /*           [2] is the black player's name */
3060                 /* For end-of-game: */
3061                 /*           [3] is the reason for the game end */
3062                 /*           [4] is a PGN end game-token, preceded by " " */
3063                 /* For start-of-game: */
3064                 /*           [3] begins with "Creating" or "Continuing" */
3065                 /*           [4] is " *" or empty (don't care). */
3066                 int gamenum = atoi(star_match[0]);
3067                 char *whitename, *blackname, *why, *endtoken;
3068                 ChessMove endtype = (ChessMove) 0;
3069
3070                 if (tkind == 0) {
3071                   whitename = star_match[1];
3072                   blackname = star_match[2];
3073                   why = star_match[3];
3074                   endtoken = star_match[4];
3075                 } else {
3076                   whitename = star_match[1];
3077                   blackname = star_match[3];
3078                   why = star_match[5];
3079                   endtoken = star_match[6];
3080                 }
3081
3082                 /* Game start messages */
3083                 if (strncmp(why, "Creating ", 9) == 0 ||
3084                     strncmp(why, "Continuing ", 11) == 0) {
3085                     gs_gamenum = gamenum;
3086                     strcpy(gs_kind, strchr(why, ' ') + 1);
3087 #if ZIPPY
3088                     if (appData.zippyPlay) {
3089                         ZippyGameStart(whitename, blackname);
3090                     }
3091 #endif /*ZIPPY*/
3092                     continue;
3093                 }
3094
3095                 /* Game end messages */
3096                 if (gameMode == IcsIdle || gameMode == BeginningOfGame ||
3097                     ics_gamenum != gamenum) {
3098                     continue;
3099                 }
3100                 while (endtoken[0] == ' ') endtoken++;
3101                 switch (endtoken[0]) {
3102                   case '*':
3103                   default:
3104                     endtype = GameUnfinished;
3105                     break;
3106                   case '0':
3107                     endtype = BlackWins;
3108                     break;
3109                   case '1':
3110                     if (endtoken[1] == '/')
3111                       endtype = GameIsDrawn;
3112                     else
3113                       endtype = WhiteWins;
3114                     break;
3115                 }
3116                 GameEnds(endtype, why, GE_ICS);
3117 #if ZIPPY
3118                 if (appData.zippyPlay && first.initDone) {
3119                     ZippyGameEnd(endtype, why);
3120                     if (first.pr == NULL) {
3121                       /* Start the next process early so that we'll
3122                          be ready for the next challenge */
3123                       StartChessProgram(&first);
3124                     }
3125                     /* Send "new" early, in case this command takes
3126                        a long time to finish, so that we'll be ready
3127                        for the next challenge. */
3128                     gameInfo.variant = VariantNormal; // [HGM] variantswitch: suppress sending of 'variant'
3129                     Reset(TRUE, TRUE);
3130                 }
3131 #endif /*ZIPPY*/
3132                 continue;
3133             }
3134
3135             if (looking_at(buf, &i, "Removing game * from observation") ||
3136                 looking_at(buf, &i, "no longer observing game *") ||
3137                 looking_at(buf, &i, "Game * (*) has no examiners")) {
3138                 if (gameMode == IcsObserving &&
3139                     atoi(star_match[0]) == ics_gamenum)
3140                   {
3141                       /* icsEngineAnalyze */
3142                       if (appData.icsEngineAnalyze) {
3143                             ExitAnalyzeMode();
3144                             ModeHighlight();
3145                       }
3146                       StopClocks();
3147                       gameMode = IcsIdle;
3148                       ics_gamenum = -1;
3149                       ics_user_moved = FALSE;
3150                   }
3151                 continue;
3152             }
3153
3154             if (looking_at(buf, &i, "no longer examining game *")) {
3155                 if (gameMode == IcsExamining &&
3156                     atoi(star_match[0]) == ics_gamenum)
3157                   {
3158                       gameMode = IcsIdle;
3159                       ics_gamenum = -1;
3160                       ics_user_moved = FALSE;
3161                   }
3162                 continue;
3163             }
3164
3165             /* Advance leftover_start past any newlines we find,
3166                so only partial lines can get reparsed */
3167             if (looking_at(buf, &i, "\n")) {
3168                 prevColor = curColor;
3169                 if (curColor != ColorNormal) {
3170                     if (oldi > next_out) {
3171                         SendToPlayer(&buf[next_out], oldi - next_out);
3172                         next_out = oldi;
3173                     }
3174                     Colorize(ColorNormal, FALSE);
3175                     curColor = ColorNormal;
3176                 }
3177                 if (started == STARTED_BOARD) {
3178                     started = STARTED_NONE;
3179                     parse[parse_pos] = NULLCHAR;
3180                     ParseBoard12(parse);
3181                     ics_user_moved = 0;
3182
3183                     /* Send premove here */
3184                     if (appData.premove) {
3185                       char str[MSG_SIZ];
3186                       if (currentMove == 0 &&
3187                           gameMode == IcsPlayingWhite &&
3188                           appData.premoveWhite) {
3189                         sprintf(str, "%s%s\n", ics_prefix,
3190                                 appData.premoveWhiteText);
3191                         if (appData.debugMode)
3192                           fprintf(debugFP, "Sending premove:\n");
3193                         SendToICS(str);
3194                       } else if (currentMove == 1 &&
3195                                  gameMode == IcsPlayingBlack &&
3196                                  appData.premoveBlack) {
3197                         sprintf(str, "%s%s\n", ics_prefix,
3198                                 appData.premoveBlackText);
3199                         if (appData.debugMode)
3200                           fprintf(debugFP, "Sending premove:\n");
3201                         SendToICS(str);
3202                       } else if (gotPremove) {
3203                         gotPremove = 0;
3204                         ClearPremoveHighlights();
3205                         if (appData.debugMode)
3206                           fprintf(debugFP, "Sending premove:\n");
3207                           UserMoveEvent(premoveFromX, premoveFromY,
3208                                         premoveToX, premoveToY,
3209                                         premovePromoChar);
3210                       }
3211                     }
3212
3213                     /* Usually suppress following prompt */
3214                     if (!(forwardMostMove == 0 && gameMode == IcsExamining)) {
3215                         if (looking_at(buf, &i, "*% ")) {
3216                             savingComment = FALSE;
3217                         }
3218                     }
3219                     next_out = i;
3220                 } else if (started == STARTED_HOLDINGS) {
3221                     int gamenum;
3222                     char new_piece[MSG_SIZ];
3223                     started = STARTED_NONE;
3224                     parse[parse_pos] = NULLCHAR;
3225                     if (appData.debugMode)
3226                       fprintf(debugFP, "Parsing holdings: %s, currentMove = %d\n",
3227                                                         parse, currentMove);
3228                     if (sscanf(parse, " game %d", &gamenum) == 1 &&
3229                         gamenum == ics_gamenum) {
3230                         if (gameInfo.variant == VariantNormal) {
3231                           /* [HGM] We seem to switch variant during a game!
3232                            * Presumably no holdings were displayed, so we have
3233                            * to move the position two files to the right to
3234                            * create room for them!
3235                            */
3236                           VariantSwitch(boards[currentMove], VariantCrazyhouse); /* temp guess */
3237                           /* Get a move list just to see the header, which
3238                              will tell us whether this is really bug or zh */
3239                           if (ics_getting_history == H_FALSE) {
3240                             ics_getting_history = H_REQUESTED;
3241                             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3242                             SendToICS(str);
3243                           }
3244                         }
3245                         new_piece[0] = NULLCHAR;
3246                         sscanf(parse, "game %d white [%s black [%s <- %s",
3247                                &gamenum, white_holding, black_holding,
3248                                new_piece);
3249                         white_holding[strlen(white_holding)-1] = NULLCHAR;
3250                         black_holding[strlen(black_holding)-1] = NULLCHAR;
3251                         /* [HGM] copy holdings to board holdings area */
3252                         CopyHoldings(boards[currentMove], white_holding, WhitePawn);
3253                         CopyHoldings(boards[currentMove], black_holding, BlackPawn);
3254 #if ZIPPY
3255                         if (appData.zippyPlay && first.initDone) {
3256                             ZippyHoldings(white_holding, black_holding,
3257                                           new_piece);
3258                         }
3259 #endif /*ZIPPY*/
3260                         if (tinyLayout || smallLayout) {
3261                             char wh[16], bh[16];
3262                             PackHolding(wh, white_holding);
3263                             PackHolding(bh, black_holding);
3264                             sprintf(str, "[%s-%s] %s-%s", wh, bh,
3265                                     gameInfo.white, gameInfo.black);
3266                         } else {
3267                             sprintf(str, "%s [%s] vs. %s [%s]",
3268                                     gameInfo.white, white_holding,
3269                                     gameInfo.black, black_holding);
3270                         }
3271
3272                         DrawPosition(FALSE, boards[currentMove]);
3273                         DisplayTitle(str);
3274                     }
3275                     /* Suppress following prompt */
3276                     if (looking_at(buf, &i, "*% ")) {
3277                         savingComment = FALSE;
3278                     }
3279                     next_out = i;
3280                 }
3281                 continue;
3282             }
3283
3284             i++;                /* skip unparsed character and loop back */
3285         }
3286
3287         if (started != STARTED_MOVES && started != STARTED_BOARD && !suppressKibitz && // [HGM] kibitz suppress printing in ICS interaction window
3288             started != STARTED_HOLDINGS && i > next_out) {
3289             SendToPlayer(&buf[next_out], i - next_out);
3290             next_out = i;
3291         }
3292         suppressKibitz = FALSE; // [HGM] kibitz: has done its duty in if-statement above
3293
3294         leftover_len = buf_len - leftover_start;
3295         /* if buffer ends with something we couldn't parse,
3296            reparse it after appending the next read */
3297
3298     } else if (count == 0) {
3299         RemoveInputSource(isr);
3300         DisplayFatalError(_("Connection closed by ICS"), 0, 0);
3301     } else {
3302         DisplayFatalError(_("Error reading from ICS"), error, 1);
3303     }
3304 }
3305
3306
3307 /* Board style 12 looks like this:
3308
3309    <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
3310
3311  * The "<12> " is stripped before it gets to this routine.  The two
3312  * trailing 0's (flip state and clock ticking) are later addition, and
3313  * some chess servers may not have them, or may have only the first.
3314  * Additional trailing fields may be added in the future.
3315  */
3316
3317 #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"
3318
3319 #define RELATION_OBSERVING_PLAYED    0
3320 #define RELATION_OBSERVING_STATIC   -2   /* examined, oldmoves, or smoves */
3321 #define RELATION_PLAYING_MYMOVE      1
3322 #define RELATION_PLAYING_NOTMYMOVE  -1
3323 #define RELATION_EXAMINING           2
3324 #define RELATION_ISOLATED_BOARD     -3
3325 #define RELATION_STARTING_POSITION  -4   /* FICS only */
3326
3327 void
3328 ParseBoard12(string)
3329      char *string;
3330 {
3331     GameMode newGameMode;
3332     int gamenum, newGame, newMove, relation, basetime, increment, ics_flip = 0, i;
3333     int j, k, n, moveNum, white_stren, black_stren, white_time, black_time, takeback;
3334     int double_push, castle_ws, castle_wl, castle_bs, castle_bl, irrev_count;
3335     char to_play, board_chars[200];
3336     char move_str[500], str[500], elapsed_time[500];
3337     char black[32], white[32];
3338     Board board;
3339     int prevMove = currentMove;
3340     int ticking = 2;
3341     ChessMove moveType;
3342     int fromX, fromY, toX, toY;
3343     char promoChar;
3344     int ranks=1, files=0; /* [HGM] ICS80: allow variable board size */
3345     char *bookHit = NULL; // [HGM] book
3346
3347     fromX = fromY = toX = toY = -1;
3348
3349     newGame = FALSE;
3350
3351     if (appData.debugMode)
3352       fprintf(debugFP, _("Parsing board: %s\n"), string);
3353
3354     move_str[0] = NULLCHAR;
3355     elapsed_time[0] = NULLCHAR;
3356     {   /* [HGM] figure out how many ranks and files the board has, for ICS extension used by Capablanca server */
3357         int  i = 0, j;
3358         while(i < 199 && (string[i] != ' ' || string[i+2] != ' ')) {
3359             if(string[i] == ' ') { ranks++; files = 0; }
3360             else files++;
3361             i++;
3362         }
3363         for(j = 0; j <i; j++) board_chars[j] = string[j];
3364         board_chars[i] = '\0';
3365         string += i + 1;
3366     }
3367     n = sscanf(string, PATTERN, &to_play, &double_push,
3368                &castle_ws, &castle_wl, &castle_bs, &castle_bl, &irrev_count,
3369                &gamenum, white, black, &relation, &basetime, &increment,
3370                &white_stren, &black_stren, &white_time, &black_time,
3371                &moveNum, str, elapsed_time, move_str, &ics_flip,
3372                &ticking);
3373
3374     if (n < 21) {
3375         snprintf(str, sizeof(str), _("Failed to parse board string:\n\"%s\""), string);
3376         DisplayError(str, 0);
3377         return;
3378     }
3379
3380     /* Convert the move number to internal form */
3381     moveNum = (moveNum - 1) * 2;
3382     if (to_play == 'B') moveNum++;
3383     if (moveNum >= MAX_MOVES) {
3384       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
3385                         0, 1);
3386       return;
3387     }
3388
3389     switch (relation) {
3390       case RELATION_OBSERVING_PLAYED:
3391       case RELATION_OBSERVING_STATIC:
3392         if (gamenum == -1) {
3393             /* Old ICC buglet */
3394             relation = RELATION_OBSERVING_STATIC;
3395         }
3396         newGameMode = IcsObserving;
3397         break;
3398       case RELATION_PLAYING_MYMOVE:
3399       case RELATION_PLAYING_NOTMYMOVE:
3400         newGameMode =
3401           ((relation == RELATION_PLAYING_MYMOVE) == (to_play == 'W')) ?
3402             IcsPlayingWhite : IcsPlayingBlack;
3403         break;
3404       case RELATION_EXAMINING:
3405         newGameMode = IcsExamining;
3406         break;
3407       case RELATION_ISOLATED_BOARD:
3408       default:
3409         /* Just display this board.  If user was doing something else,
3410            we will forget about it until the next board comes. */
3411         newGameMode = IcsIdle;
3412         break;
3413       case RELATION_STARTING_POSITION:
3414         newGameMode = gameMode;
3415         break;
3416     }
3417
3418     /* Modify behavior for initial board display on move listing
3419        of wild games.
3420        */
3421     switch (ics_getting_history) {
3422       case H_FALSE:
3423       case H_REQUESTED:
3424         break;
3425       case H_GOT_REQ_HEADER:
3426       case H_GOT_UNREQ_HEADER:
3427         /* This is the initial position of the current game */
3428         gamenum = ics_gamenum;
3429         moveNum = 0;            /* old ICS bug workaround */
3430         if (to_play == 'B') {
3431           startedFromSetupPosition = TRUE;
3432           blackPlaysFirst = TRUE;
3433           moveNum = 1;
3434           if (forwardMostMove == 0) forwardMostMove = 1;
3435           if (backwardMostMove == 0) backwardMostMove = 1;
3436           if (currentMove == 0) currentMove = 1;
3437         }
3438         newGameMode = gameMode;
3439         relation = RELATION_STARTING_POSITION; /* ICC needs this */
3440         break;
3441       case H_GOT_UNWANTED_HEADER:
3442         /* This is an initial board that we don't want */
3443         return;
3444       case H_GETTING_MOVES:
3445         /* Should not happen */
3446         DisplayError(_("Error gathering move list: extra board"), 0);
3447         ics_getting_history = H_FALSE;
3448         return;
3449     }
3450
3451     /* Take action if this is the first board of a new game, or of a
3452        different game than is currently being displayed.  */
3453     if (gamenum != ics_gamenum || newGameMode != gameMode ||
3454         relation == RELATION_ISOLATED_BOARD) {
3455
3456         /* Forget the old game and get the history (if any) of the new one */
3457         if (gameMode != BeginningOfGame) {
3458           Reset(FALSE, TRUE);
3459         }
3460         newGame = TRUE;
3461         if (appData.autoRaiseBoard) BoardToTop();
3462         prevMove = -3;
3463         if (gamenum == -1) {
3464             newGameMode = IcsIdle;
3465         } else if (moveNum > 0 && newGameMode != IcsIdle &&
3466                    appData.getMoveList) {
3467             /* Need to get game history */
3468             ics_getting_history = H_REQUESTED;
3469             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3470             SendToICS(str);
3471         }
3472
3473         /* Initially flip the board to have black on the bottom if playing
3474            black or if the ICS flip flag is set, but let the user change
3475            it with the Flip View button. */
3476         flipView = appData.autoFlipView ?
3477           (newGameMode == IcsPlayingBlack) || ics_flip :
3478           appData.flipView;
3479
3480         /* Done with values from previous mode; copy in new ones */
3481         gameMode = newGameMode;
3482         ModeHighlight();
3483         ics_gamenum = gamenum;
3484         if (gamenum == gs_gamenum) {
3485             int klen = strlen(gs_kind);
3486             if (gs_kind[klen - 1] == '.') gs_kind[klen - 1] = NULLCHAR;
3487             sprintf(str, "ICS %s", gs_kind);
3488             gameInfo.event = StrSave(str);
3489         } else {
3490             gameInfo.event = StrSave("ICS game");
3491         }
3492         gameInfo.site = StrSave(appData.icsHost);
3493         gameInfo.date = PGNDate();
3494         gameInfo.round = StrSave("-");
3495         gameInfo.white = StrSave(white);
3496         gameInfo.black = StrSave(black);
3497         timeControl = basetime * 60 * 1000;
3498         timeControl_2 = 0;
3499         timeIncrement = increment * 1000;
3500         movesPerSession = 0;
3501         gameInfo.timeControl = TimeControlTagValue();
3502         VariantSwitch(board, StringToVariant(gameInfo.event) );
3503   if (appData.debugMode) {
3504     fprintf(debugFP, "ParseBoard says variant = '%s'\n", gameInfo.event);
3505     fprintf(debugFP, "recognized as %s\n", VariantName(gameInfo.variant));
3506     setbuf(debugFP, NULL);
3507   }
3508
3509         gameInfo.outOfBook = NULL;
3510
3511         /* Do we have the ratings? */
3512         if (strcmp(player1Name, white) == 0 &&
3513             strcmp(player2Name, black) == 0) {
3514             if (appData.debugMode)
3515               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
3516                       player1Rating, player2Rating);
3517             gameInfo.whiteRating = player1Rating;
3518             gameInfo.blackRating = player2Rating;
3519         } else if (strcmp(player2Name, white) == 0 &&
3520                    strcmp(player1Name, black) == 0) {
3521             if (appData.debugMode)
3522               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
3523                       player2Rating, player1Rating);
3524             gameInfo.whiteRating = player2Rating;
3525             gameInfo.blackRating = player1Rating;
3526         }
3527         player1Name[0] = player2Name[0] = NULLCHAR;
3528
3529         /* Silence shouts if requested */
3530         if (appData.quietPlay &&
3531             (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)) {
3532             SendToICS(ics_prefix);
3533             SendToICS("set shout 0\n");
3534         }
3535     }
3536
3537     /* Deal with midgame name changes */
3538     if (!newGame) {
3539         if (!gameInfo.white || strcmp(gameInfo.white, white) != 0) {
3540             if (gameInfo.white) free(gameInfo.white);
3541             gameInfo.white = StrSave(white);
3542         }
3543         if (!gameInfo.black || strcmp(gameInfo.black, black) != 0) {
3544             if (gameInfo.black) free(gameInfo.black);
3545             gameInfo.black = StrSave(black);
3546         }
3547     }
3548
3549     /* Throw away game result if anything actually changes in examine mode */
3550     if (gameMode == IcsExamining && !newGame) {
3551         gameInfo.result = GameUnfinished;
3552         if (gameInfo.resultDetails != NULL) {
3553             free(gameInfo.resultDetails);
3554             gameInfo.resultDetails = NULL;
3555         }
3556     }
3557
3558     /* In pausing && IcsExamining mode, we ignore boards coming
3559        in if they are in a different variation than we are. */
3560     if (pauseExamInvalid) return;
3561     if (pausing && gameMode == IcsExamining) {
3562         if (moveNum <= pauseExamForwardMostMove) {
3563             pauseExamInvalid = TRUE;
3564             forwardMostMove = pauseExamForwardMostMove;
3565             return;
3566         }
3567     }
3568
3569   if (appData.debugMode) {
3570     fprintf(debugFP, "load %dx%d board\n", files, ranks);
3571   }
3572     /* Parse the board */
3573     for (k = 0; k < ranks; k++) {
3574       for (j = 0; j < files; j++)
3575         board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
3576       if(gameInfo.holdingsWidth > 1) {
3577            board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
3578            board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
3579       }
3580     }
3581     CopyBoard(boards[moveNum], board);
3582     if (moveNum == 0) {
3583         startedFromSetupPosition =
3584           !CompareBoards(board, initialPosition);
3585         if(startedFromSetupPosition)
3586             initialRulePlies = irrev_count; /* [HGM] 50-move counter offset */
3587     }
3588
3589     /* [HGM] Set castling rights. Take the outermost Rooks,
3590        to make it also work for FRC opening positions. Note that board12
3591        is really defective for later FRC positions, as it has no way to
3592        indicate which Rook can castle if they are on the same side of King.
3593        For the initial position we grant rights to the outermost Rooks,
3594        and remember thos rights, and we then copy them on positions
3595        later in an FRC game. This means WB might not recognize castlings with
3596        Rooks that have moved back to their original position as illegal,
3597        but in ICS mode that is not its job anyway.
3598     */
3599     if(moveNum == 0 || gameInfo.variant != VariantFischeRandom)
3600     { int i, j; ChessSquare wKing = WhiteKing, bKing = BlackKing;
3601
3602         for(i=BOARD_LEFT, j= -1; i<BOARD_RGHT; i++)
3603             if(board[0][i] == WhiteRook) j = i;
3604         initialRights[0] = castlingRights[moveNum][0] = (castle_ws == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3605         for(i=BOARD_RGHT-1, j= -1; i>=BOARD_LEFT; i--)
3606             if(board[0][i] == WhiteRook) j = i;
3607         initialRights[1] = castlingRights[moveNum][1] = (castle_wl == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3608         for(i=BOARD_LEFT, j= -1; i<BOARD_RGHT; i++)
3609             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
3610         initialRights[3] = castlingRights[moveNum][3] = (castle_bs == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3611         for(i=BOARD_RGHT-1, j= -1; i>=BOARD_LEFT; i--)
3612             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
3613         initialRights[4] = castlingRights[moveNum][4] = (castle_bl == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3614
3615         if(gameInfo.variant == VariantKnightmate) { wKing = WhiteUnicorn; bKing = BlackUnicorn; }
3616         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
3617             if(board[0][k] == wKing) initialRights[2] = castlingRights[moveNum][2] = k;
3618         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
3619             if(board[BOARD_HEIGHT-1][k] == bKing)
3620                 initialRights[5] = castlingRights[moveNum][5] = k;
3621     } else { int r;
3622         r = castlingRights[moveNum][0] = initialRights[0];
3623         if(board[0][r] != WhiteRook) castlingRights[moveNum][0] = -1;
3624         r = castlingRights[moveNum][1] = initialRights[1];
3625         if(board[0][r] != WhiteRook) castlingRights[moveNum][1] = -1;
3626         r = castlingRights[moveNum][3] = initialRights[3];
3627         if(board[BOARD_HEIGHT-1][r] != BlackRook) castlingRights[moveNum][3] = -1;
3628         r = castlingRights[moveNum][4] = initialRights[4];
3629         if(board[BOARD_HEIGHT-1][r] != BlackRook) castlingRights[moveNum][4] = -1;
3630         /* wildcastle kludge: always assume King has rights */
3631         r = castlingRights[moveNum][2] = initialRights[2];
3632         r = castlingRights[moveNum][5] = initialRights[5];
3633     }
3634     /* [HGM] e.p. rights. Assume that ICS sends file number here? */
3635     epStatus[moveNum] = double_push == -1 ? EP_NONE : double_push + BOARD_LEFT;
3636
3637
3638     if (ics_getting_history == H_GOT_REQ_HEADER ||
3639         ics_getting_history == H_GOT_UNREQ_HEADER) {
3640         /* This was an initial position from a move list, not
3641            the current position */
3642         return;
3643     }
3644
3645     /* Update currentMove and known move number limits */
3646     newMove = newGame || moveNum > forwardMostMove;
3647
3648     /* [DM] If we found takebacks during icsEngineAnalyze try send to engine */
3649     if (!newGame && appData.icsEngineAnalyze && moveNum < forwardMostMove) {
3650         takeback = forwardMostMove - moveNum;
3651         for (i = 0; i < takeback; i++) {
3652              if (appData.debugMode) fprintf(debugFP, "take back move\n");
3653              SendToProgram("undo\n", &first);
3654         }
3655     }
3656
3657     if (newGame) {
3658         forwardMostMove = backwardMostMove = currentMove = moveNum;
3659         if (gameMode == IcsExamining && moveNum == 0) {
3660           /* Workaround for ICS limitation: we are not told the wild
3661              type when starting to examine a game.  But if we ask for
3662              the move list, the move list header will tell us */
3663             ics_getting_history = H_REQUESTED;
3664             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3665             SendToICS(str);
3666         }
3667     } else if (moveNum == forwardMostMove + 1 || moveNum == forwardMostMove
3668                || (moveNum < forwardMostMove && moveNum >= backwardMostMove)) {
3669         forwardMostMove = moveNum;
3670         if (!pausing || currentMove > forwardMostMove)
3671           currentMove = forwardMostMove;
3672     } else {
3673         /* New part of history that is not contiguous with old part */
3674         if (pausing && gameMode == IcsExamining) {
3675             pauseExamInvalid = TRUE;
3676             forwardMostMove = pauseExamForwardMostMove;
3677             return;
3678         }
3679         forwardMostMove = backwardMostMove = currentMove = moveNum;
3680         if (gameMode == IcsExamining && moveNum > 0 && appData.getMoveList) {
3681             ics_getting_history = H_REQUESTED;
3682             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3683             SendToICS(str);
3684         }
3685     }
3686
3687     /* Update the clocks */
3688     if (strchr(elapsed_time, '.')) {
3689       /* Time is in ms */
3690       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time;
3691       timeRemaining[1][moveNum] = blackTimeRemaining = black_time;
3692     } else {
3693       /* Time is in seconds */
3694       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time * 1000;
3695       timeRemaining[1][moveNum] = blackTimeRemaining = black_time * 1000;
3696     }
3697
3698
3699 #if ZIPPY
3700     if (appData.zippyPlay && newGame &&
3701         gameMode != IcsObserving && gameMode != IcsIdle &&
3702         gameMode != IcsExamining)
3703       ZippyFirstBoard(moveNum, basetime, increment);
3704 #endif
3705
3706     /* Put the move on the move list, first converting
3707        to canonical algebraic form. */
3708     if (moveNum > 0) {
3709   if (appData.debugMode) {
3710     if (appData.debugMode) { int f = forwardMostMove;
3711         fprintf(debugFP, "parseboard %d, castling = %d %d %d %d %d %d\n", f,
3712                 castlingRights[f][0],castlingRights[f][1],castlingRights[f][2],castlingRights[f][3],castlingRights[f][4],castlingRights[f][5]);
3713     }
3714     fprintf(debugFP, "accepted move %s from ICS, parse it.\n", move_str);
3715     fprintf(debugFP, "moveNum = %d\n", moveNum);
3716     fprintf(debugFP, "board = %d-%d x %d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT);
3717     setbuf(debugFP, NULL);
3718   }
3719         if (moveNum <= backwardMostMove) {
3720             /* We don't know what the board looked like before
3721                this move.  Punt. */
3722             strcpy(parseList[moveNum - 1], move_str);
3723             strcat(parseList[moveNum - 1], " ");
3724             strcat(parseList[moveNum - 1], elapsed_time);
3725             moveList[moveNum - 1][0] = NULLCHAR;
3726         } else if (strcmp(move_str, "none") == 0) {
3727             // [HGM] long SAN: swapped order; test for 'none' before parsing move
3728             /* Again, we don't know what the board looked like;
3729                this is really the start of the game. */
3730             parseList[moveNum - 1][0] = NULLCHAR;
3731             moveList[moveNum - 1][0] = NULLCHAR;
3732             backwardMostMove = moveNum;
3733             startedFromSetupPosition = TRUE;
3734             fromX = fromY = toX = toY = -1;
3735         } else {
3736           // [HGM] long SAN: if legality-testing is off, disambiguation might not work or give wrong move.
3737           //                 So we parse the long-algebraic move string in stead of the SAN move
3738           int valid; char buf[MSG_SIZ], *prom;
3739
3740           // str looks something like "Q/a1-a2"; kill the slash
3741           if(str[1] == '/')
3742                 sprintf(buf, "%c%s", str[0], str+2);
3743           else  strcpy(buf, str); // might be castling
3744           if((prom = strstr(move_str, "=")) && !strstr(buf, "="))
3745                 strcat(buf, prom); // long move lacks promo specification!
3746           if(!appData.testLegality && move_str[1] != '@') { // drops never ambiguous (parser chokes on long form!)
3747                 if(appData.debugMode)
3748                         fprintf(debugFP, "replaced ICS move '%s' by '%s'\n", move_str, buf);
3749                 strcpy(move_str, buf);
3750           }
3751           valid = ParseOneMove(move_str, moveNum - 1, &moveType,
3752                                 &fromX, &fromY, &toX, &toY, &promoChar)
3753                || ParseOneMove(buf, moveNum - 1, &moveType,
3754                                 &fromX, &fromY, &toX, &toY, &promoChar);
3755           // end of long SAN patch
3756           if (valid) {
3757             (void) CoordsToAlgebraic(boards[moveNum - 1],
3758                                      PosFlags(moveNum - 1), EP_UNKNOWN,
3759                                      fromY, fromX, toY, toX, promoChar,
3760                                      parseList[moveNum-1]);
3761             switch (MateTest(boards[moveNum], PosFlags(moveNum), EP_UNKNOWN,
3762                              castlingRights[moveNum]) ) {
3763               case MT_NONE:
3764               case MT_STALEMATE:
3765               default:
3766                 break;
3767               case MT_CHECK:
3768                 if(gameInfo.variant != VariantShogi)
3769                     strcat(parseList[moveNum - 1], "+");
3770                 break;
3771               case MT_CHECKMATE:
3772               case MT_STAINMATE: // [HGM] xq: for notation stalemate that wins counts as checkmate
3773                 strcat(parseList[moveNum - 1], "#");
3774                 break;
3775             }
3776             strcat(parseList[moveNum - 1], " ");
3777             strcat(parseList[moveNum - 1], elapsed_time);
3778             /* currentMoveString is set as a side-effect of ParseOneMove */
3779             strcpy(moveList[moveNum - 1], currentMoveString);
3780             strcat(moveList[moveNum - 1], "\n");
3781           } else {
3782             /* Move from ICS was illegal!?  Punt. */
3783   if (appData.debugMode) {
3784     fprintf(debugFP, "Illegal move from ICS '%s'\n", move_str);
3785     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
3786   }
3787             strcpy(parseList[moveNum - 1], move_str);
3788             strcat(parseList[moveNum - 1], " ");
3789             strcat(parseList[moveNum - 1], elapsed_time);
3790             moveList[moveNum - 1][0] = NULLCHAR;
3791             fromX = fromY = toX = toY = -1;
3792           }
3793         }
3794   if (appData.debugMode) {
3795     fprintf(debugFP, "Move parsed to '%s'\n", parseList[moveNum - 1]);
3796     setbuf(debugFP, NULL);
3797   }
3798
3799 #if ZIPPY
3800         /* Send move to chess program (BEFORE animating it). */
3801         if (appData.zippyPlay && !newGame && newMove &&
3802            (!appData.getMoveList || backwardMostMove == 0) && first.initDone) {
3803
3804             if ((gameMode == IcsPlayingWhite && WhiteOnMove(moveNum)) ||
3805                 (gameMode == IcsPlayingBlack && !WhiteOnMove(moveNum))) {
3806                 if (moveList[moveNum - 1][0] == NULLCHAR) {
3807                     sprintf(str, _("Couldn't parse move \"%s\" from ICS"),
3808                             move_str);
3809                     DisplayError(str, 0);
3810                 } else {
3811                     if (first.sendTime) {
3812                         SendTimeRemaining(&first, gameMode == IcsPlayingWhite);
3813                     }
3814                     bookHit = SendMoveToBookUser(moveNum - 1, &first, FALSE); // [HGM] book
3815                     if (firstMove && !bookHit) {
3816                         firstMove = FALSE;
3817                         if (first.useColors) {
3818                           SendToProgram(gameMode == IcsPlayingWhite ?
3819                                         "white\ngo\n" :
3820                                         "black\ngo\n", &first);
3821                         } else {
3822                           SendToProgram("go\n", &first);
3823                         }
3824                         first.maybeThinking = TRUE;
3825                     }
3826