backend.c

   1 /*
   2  * backend.c -- Common back end for X and Windows NT versions of
   3  *
   4  * Copyright 1991 by Digital Equipment Corporation, Maynard,
   5  * Massachusetts.
   6  *
   7  * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
   8  * 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   9  *
  10  * Enhancements Copyright 2005 Alessandro Scotti
  11  *
  12  * The following terms apply to Digital Equipment Corporation's copyright
  13  * interest in XBoard:
  14  * ------------------------------------------------------------------------
  15  * All Rights Reserved
  16  *
  17  * Permission to use, copy, modify, and distribute this software and its
  18  * documentation for any purpose and without fee is hereby granted,
  19  * provided that the above copyright notice appear in all copies and that
  20  * both that copyright notice and this permission notice appear in
  21  * supporting documentation, and that the name of Digital not be
  22  * used in advertising or publicity pertaining to distribution of the
  23  * software without specific, written prior permission.
  24  *
  25  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  26  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  27  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  28  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  29  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  30  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  31  * SOFTWARE.
  32  * ------------------------------------------------------------------------
  33  *
  34  * The following terms apply to the enhanced version of XBoard
  35  * distributed by the Free Software Foundation:
  36  * ------------------------------------------------------------------------
  37  *
  38  * GNU XBoard is free software: you can redistribute it and/or modify
  39  * it under the terms of the GNU General Public License as published by
  40  * the Free Software Foundation, either version 3 of the License, or (at
  41  * your option) any later version.
  42  *
  43  * GNU XBoard is distributed in the hope that it will be useful, but
  44  * WITHOUT ANY WARRANTY; without even the implied warranty of
  45  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  46  * General Public License for more details.
  47  *
  48  * You should have received a copy of the GNU General Public License
  49  * along with this program. If not, see http://www.gnu.org/licenses/.  *
  50  *
  51  *------------------------------------------------------------------------
  52  ** See the file ChangeLog for a revision history.  */
  53
  54 /* [AS] Also useful here for debugging */
  55 #ifdef WIN32
  56 #include <windows.h>
  57
  58 #define DoSleep( n ) if( (n) != 0 ) Sleep( (n) );
  59
  60 #else
  61
  62 #define DoSleep( n ) if( (n) >= 0) sleep(n)
  63
  64 #endif
  65
  66 #include "config.h"
  67
  68 #include <assert.h>
  69 #include <stdio.h>
  70 #include <ctype.h>
  71 #include <errno.h>
  72 #include <sys/types.h>
  73 #include <sys/stat.h>
  74 #include <math.h>
  75 #include <ctype.h>
  76
  77 #if STDC_HEADERS
  78 # include <stdlib.h>
  79 # include <string.h>
  80 # include <stdarg.h>
  81 #else /* not STDC_HEADERS */
  82 # if HAVE_STRING_H
  83 #  include <string.h>
  84 # else /* not HAVE_STRING_H */
  85 #  include <strings.h>
  86 # endif /* not HAVE_STRING_H */
  87 #endif /* not STDC_HEADERS */
  88
  89 #if HAVE_SYS_FCNTL_H
  90 # include <sys/fcntl.h>
  91 #else /* not HAVE_SYS_FCNTL_H */
  92 # if HAVE_FCNTL_H
  93 #  include <fcntl.h>
  94 # endif /* HAVE_FCNTL_H */
  95 #endif /* not HAVE_SYS_FCNTL_H */
  96
  97 #if TIME_WITH_SYS_TIME
  98 # include <sys/time.h>
  99 # include <time.h>
 100 #else
 101 # if HAVE_SYS_TIME_H
 102 #  include <sys/time.h>
 103 # else
 104 #  include <time.h>
 105 # endif
 106 #endif
 107
 108 #if defined(_amigados) && !defined(__GNUC__)
 109 struct timezone {
 110     int tz_minuteswest;
 111     int tz_dsttime;
 112 };
 113 extern int gettimeofday(struct timeval *, struct timezone *);
 114 #endif
 115
 116 #if HAVE_UNISTD_H
 117 # include <unistd.h>
 118 #endif
 119
 120 #include "common.h"
 121 #include "frontend.h"
 122 #include "backend.h"
 123 #include "parser.h"
 124 #include "moves.h"
 125 #if ZIPPY
 126 # include "zippy.h"
 127 #endif
 128 #include "backendz.h"
 129 #include "gettext.h"
 130
 131 #ifdef ENABLE_NLS
 132 # define _(s) gettext (s)
 133 # define N_(s) gettext_noop (s)
 134 #else
 135 # define _(s) (s)
 136 # define N_(s) s
 137 #endif
 138
 139
 140 /* A point in time */
 141 typedef struct {
 142     long sec;  /* Assuming this is >= 32 bits */
 143     int ms;    /* Assuming this is >= 16 bits */
 144 } TimeMark;
 145
 146 int establish P((void));
 147 void read_from_player P((InputSourceRef isr, VOIDSTAR closure,
 148                          char *buf, int count, int error));
 149 void read_from_ics P((InputSourceRef isr, VOIDSTAR closure,
 150                       char *buf, int count, int error));
 151 void ics_printf P((char *format, ...));
 152 void SendToICS P((char *s));
 153 void SendToICSDelayed P((char *s, long msdelay));
 154 void SendMoveToICS P((ChessMove moveType, int fromX, int fromY,
 155                       int toX, int toY));
 156 void HandleMachineMove P((char *message, ChessProgramState *cps));
 157 int AutoPlayOneMove P((void));
 158 int LoadGameOneMove P((ChessMove readAhead));
 159 int LoadGameFromFile P((char *filename, int n, char *title, int useList));
 160 int LoadPositionFromFile P((char *filename, int n, char *title));
 161 int SavePositionToFile P((char *filename));
 162 void ApplyMove P((int fromX, int fromY, int toX, int toY, int promoChar,
 163                                                                                 Board board));
 164 void MakeMove P((int fromX, int fromY, int toX, int toY, int promoChar));
 165 void ShowMove P((int fromX, int fromY, int toX, int toY));
 166 int FinishMove P((ChessMove moveType, int fromX, int fromY, int toX, int toY,
 167                    /*char*/int promoChar));
 168 void BackwardInner P((int target));
 169 void ForwardInner P((int target));
 170 int Adjudicate P((ChessProgramState *cps));
 171 void GameEnds P((ChessMove result, char *resultDetails, int whosays));
 172 void EditPositionDone P((Boolean fakeRights));
 173 void PrintOpponents P((FILE *fp));
 174 void PrintPosition P((FILE *fp, int move));
 175 void StartChessProgram P((ChessProgramState *cps));
 176 void SendToProgram P((char *message, ChessProgramState *cps));
 177 void SendMoveToProgram P((int moveNum, ChessProgramState *cps));
 178 void ReceiveFromProgram P((InputSourceRef isr, VOIDSTAR closure,
 179                            char *buf, int count, int error));
 180 void SendTimeControl P((ChessProgramState *cps,
 181                         int mps, long tc, int inc, int sd, int st));
 182 char *TimeControlTagValue P((void));
 183 void Attention P((ChessProgramState *cps));
 184 void FeedMovesToProgram P((ChessProgramState *cps, int upto));
 185 void ResurrectChessProgram P((void));
 186 void DisplayComment P((int moveNumber, char *text));
 187 void DisplayMove P((int moveNumber));
 188
 189 void ParseGameHistory P((char *game));
 190 void ParseBoard12 P((char *string));
 191 void KeepAlive P((void));
 192 void StartClocks P((void));
 193 void SwitchClocks P((int nr));
 194 void StopClocks P((void));
 195 void ResetClocks P((void));
 196 char *PGNDate P((void));
 197 void SetGameInfo P((void));
 198 Boolean ParseFEN P((Board board, int *blackPlaysFirst, char *fen));
 199 int RegisterMove P((void));
 200 void MakeRegisteredMove P((void));
 201 void TruncateGame P((void));
 202 int looking_at P((char *, int *, char *));
 203 void CopyPlayerNameIntoFileName P((char **, char *));
 204 char *SavePart P((char *));
 205 int SaveGameOldStyle P((FILE *));
 206 int SaveGamePGN P((FILE *));
 207 void GetTimeMark P((TimeMark *));
 208 long SubtractTimeMarks P((TimeMark *, TimeMark *));
 209 int CheckFlags P((void));
 210 long NextTickLength P((long));
 211 void CheckTimeControl P((void));
 212 void show_bytes P((FILE *, char *, int));
 213 int string_to_rating P((char *str));
 214 void ParseFeatures P((char* args, ChessProgramState *cps));
 215 void InitBackEnd3 P((void));
 216 void FeatureDone P((ChessProgramState* cps, int val));
 217 void InitChessProgram P((ChessProgramState *cps, int setup));
 218 void OutputKibitz(int window, char *text);
 219 int PerpetualChase(int first, int last);
 220 int EngineOutputIsUp();
 221 void InitDrawingSizes(int x, int y);
 222
 223 #ifdef WIN32
 224        extern void ConsoleCreate();
 225 #endif
 226
 227 ChessProgramState *WhitePlayer();
 228 void InsertIntoMemo P((int which, char *text)); // [HGM] kibitz: in engineo.c
 229 int VerifyDisplayMode P(());
 230
 231 char *GetInfoFromComment( int, char * ); // [HGM] PV time: returns stripped comment
 232 void InitEngineUCI( const char * iniDir, ChessProgramState * cps ); // [HGM] moved here from winboard.c
 233 char *ProbeBook P((int moveNr, char *book)); // [HGM] book: returns a book move
 234 char *SendMoveToBookUser P((int nr, ChessProgramState *cps, int initial)); // [HGM] book
 235 void ics_update_width P((int new_width));
 236 extern char installDir[MSG_SIZ];
 237 VariantClass startVariant; /* [HGM] nicks: initial variant */
 238
 239 extern int tinyLayout, smallLayout;
 240 ChessProgramStats programStats;
 241 char lastPV[2][2*MSG_SIZ]; /* [HGM] pv: last PV in thinking output of each engine */
 242 int endPV = -1;
 243 static int exiting = 0; /* [HGM] moved to top */
 244 static int setboardSpoiledMachineBlack = 0 /*, errorExitFlag = 0*/;
 245 int startedFromPositionFile = FALSE; Board filePosition;       /* [HGM] loadPos */
 246 Board partnerBoard;     /* [HGM] bughouse: for peeking at partner game          */
 247 int partnerHighlight[2];
 248 Boolean partnerBoardValid = 0;
 249 char partnerStatus[MSG_SIZ];
 250 Boolean partnerUp;
 251 Boolean originalFlip;
 252 Boolean twoBoards = 0;
 253 char endingGame = 0;    /* [HGM] crash: flag to prevent recursion of GameEnds() */
 254 int whiteNPS, blackNPS; /* [HGM] nps: for easily making clocks aware of NPS     */
 255 VariantClass currentlyInitializedVariant; /* [HGM] variantswitch */
 256 int lastIndex = 0;      /* [HGM] autoinc: last game/position used in match mode */
 257 Boolean connectionAlive;/* [HGM] alive: ICS connection status from probing      */
 258 int opponentKibitzes;
 259 int lastSavedGame; /* [HGM] save: ID of game */
 260 char chatPartner[MAX_CHAT][MSG_SIZ]; /* [HGM] chat: list of chatting partners */
 261 extern int chatCount;
 262 int chattingPartner;
 263 char marker[BOARD_RANKS][BOARD_FILES]; /* [HGM] marks for target squares */
 264
 265 /* States for ics_getting_history */
 266 #define H_FALSE 0
 267 #define H_REQUESTED 1
 268 #define H_GOT_REQ_HEADER 2
 269 #define H_GOT_UNREQ_HEADER 3
 270 #define H_GETTING_MOVES 4
 271 #define H_GOT_UNWANTED_HEADER 5
 272
 273 /* whosays values for GameEnds */
 274 #define GE_ICS 0
 275 #define GE_ENGINE 1
 276 #define GE_PLAYER 2
 277 #define GE_FILE 3
 278 #define GE_XBOARD 4
 279 #define GE_ENGINE1 5
 280 #define GE_ENGINE2 6
 281
 282 /* Maximum number of games in a cmail message */
 283 #define CMAIL_MAX_GAMES 20
 284
 285 /* Different types of move when calling RegisterMove */
 286 #define CMAIL_MOVE   0
 287 #define CMAIL_RESIGN 1
 288 #define CMAIL_DRAW   2
 289 #define CMAIL_ACCEPT 3
 290
 291 /* Different types of result to remember for each game */
 292 #define CMAIL_NOT_RESULT 0
 293 #define CMAIL_OLD_RESULT 1
 294 #define CMAIL_NEW_RESULT 2
 295
 296 /* Telnet protocol constants */
 297 #define TN_WILL 0373
 298 #define TN_WONT 0374
 299 #define TN_DO   0375
 300 #define TN_DONT 0376
 301 #define TN_IAC  0377
 302 #define TN_ECHO 0001
 303 #define TN_SGA  0003
 304 #define TN_PORT 23
 305
 306 /* [AS] */
 307 static char * safeStrCpy( char * dst, const char * src, size_t count )
 308 {
 309     assert( dst != NULL );
 310     assert( src != NULL );
 311     assert( count > 0 );
 312
 313     strncpy( dst, src, count );
 314     dst[ count-1 ] = '\0';
 315     return dst;
 316 }
 317
 318 /* Some compiler can't cast u64 to double
 319  * This function do the job for us:
 320
 321  * We use the highest bit for cast, this only
 322  * works if the highest bit is not
 323  * in use (This should not happen)
 324  *
 325  * We used this for all compiler
 326  */
 327 double
 328 u64ToDouble(u64 value)
 329 {
 330   double r;
 331   u64 tmp = value & u64Const(0x7fffffffffffffff);
 332   r = (double)(s64)tmp;
 333   if (value & u64Const(0x8000000000000000))
 334        r +=  9.2233720368547758080e18; /* 2^63 */
 335  return r;
 336 }
 337
 338 /* Fake up flags for now, as we aren't keeping track of castling
 339    availability yet. [HGM] Change of logic: the flag now only
 340    indicates the type of castlings allowed by the rule of the game.
 341    The actual rights themselves are maintained in the array
 342    castlingRights, as part of the game history, and are not probed
 343    by this function.
 344  */
 345 int
 346 PosFlags(index)
 347 {
 348   int flags = F_ALL_CASTLE_OK;
 349   if ((index % 2) == 0) flags |= F_WHITE_ON_MOVE;
 350   switch (gameInfo.variant) {
 351   case VariantSuicide:
 352     flags &= ~F_ALL_CASTLE_OK;
 353   case VariantGiveaway:         // [HGM] moved this case label one down: seems Giveaway does have castling on ICC!
 354     flags |= F_IGNORE_CHECK;
 355   case VariantLosers:
 356     flags |= F_MANDATORY_CAPTURE; //[HGM] losers: sets flag so TestLegality rejects non-capts if capts exist
 357     break;
 358   case VariantAtomic:
 359     flags |= F_IGNORE_CHECK | F_ATOMIC_CAPTURE;
 360     break;
 361   case VariantKriegspiel:
 362     flags |= F_KRIEGSPIEL_CAPTURE;
 363     break;
 364   case VariantCapaRandom:
 365   case VariantFischeRandom:
 366     flags |= F_FRC_TYPE_CASTLING; /* [HGM] enable this through flag */
 367   case VariantNoCastle:
 368   case VariantShatranj:
 369   case VariantCourier:
 370   case VariantMakruk:
 371     flags &= ~F_ALL_CASTLE_OK;
 372     break;
 373   default:
 374     break;
 375   }
 376   return flags;
 377 }
 378
 379 FILE *gameFileFP, *debugFP;
 380
 381 /*
 382     [AS] Note: sometimes, the sscanf() function is used to parse the input
 383     into a fixed-size buffer. Because of this, we must be prepared to
 384     receive strings as long as the size of the input buffer, which is currently
 385     set to 4K for Windows and 8K for the rest.
 386     So, we must either allocate sufficiently large buffers here, or
 387     reduce the size of the input buffer in the input reading part.
 388 */
 389
 390 char cmailMove[CMAIL_MAX_GAMES][MOVE_LEN], cmailMsg[MSG_SIZ];
 391 char bookOutput[MSG_SIZ*10], thinkOutput[MSG_SIZ*10], lastHint[MSG_SIZ];
 392 char thinkOutput1[MSG_SIZ*10];
 393
 394 ChessProgramState first, second;
 395
 396 /* premove variables */
 397 int premoveToX = 0;
 398 int premoveToY = 0;
 399 int premoveFromX = 0;
 400 int premoveFromY = 0;
 401 int premovePromoChar = 0;
 402 int gotPremove = 0;
 403 Boolean alarmSounded;
 404 /* end premove variables */
 405
 406 char *ics_prefix = "$";
 407 int ics_type = ICS_GENERIC;
 408
 409 int currentMove = 0, forwardMostMove = 0, backwardMostMove = 0;
 410 int pauseExamForwardMostMove = 0;
 411 int nCmailGames = 0, nCmailResults = 0, nCmailMovesRegistered = 0;
 412 int cmailMoveRegistered[CMAIL_MAX_GAMES], cmailResult[CMAIL_MAX_GAMES];
 413 int cmailMsgLoaded = FALSE, cmailMailedMove = FALSE;
 414 int cmailOldMove = -1, firstMove = TRUE, flipView = FALSE;
 415 int blackPlaysFirst = FALSE, startedFromSetupPosition = FALSE;
 416 int searchTime = 0, pausing = FALSE, pauseExamInvalid = FALSE;
 417 int whiteFlag = FALSE, blackFlag = FALSE;
 418 int userOfferedDraw = FALSE;
 419 int ics_user_moved = 0, ics_gamenum = -1, ics_getting_history = H_FALSE;
 420 int matchMode = FALSE, hintRequested = FALSE, bookRequested = FALSE;
 421 int cmailMoveType[CMAIL_MAX_GAMES];
 422 long ics_clock_paused = 0;
 423 ProcRef icsPR = NoProc, cmailPR = NoProc;
 424 InputSourceRef telnetISR = NULL, fromUserISR = NULL, cmailISR = NULL;
 425 GameMode gameMode = BeginningOfGame;
 426 char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2];
 427 char *commentList[MAX_MOVES], *cmailCommentList[CMAIL_MAX_GAMES];
 428 ChessProgramStats_Move pvInfoList[MAX_MOVES]; /* [AS] Info about engine thinking */
 429 int hiddenThinkOutputState = 0; /* [AS] */
 430 int adjudicateLossThreshold = 0; /* [AS] Automatic adjudication */
 431 int adjudicateLossPlies = 6;
 432 char white_holding[64], black_holding[64];
 433 TimeMark lastNodeCountTime;
 434 long lastNodeCount=0;
 435 int have_sent_ICS_logon = 0;
 436 int movesPerSession;
 437 long whiteTimeRemaining, blackTimeRemaining, timeControl, timeIncrement;
 438 long timeControl_2; /* [AS] Allow separate time controls */
 439 char *fullTimeControlString = NULL; /* [HGM] secondary TC: merge of MPS, TC and inc */
 440 long timeRemaining[2][MAX_MOVES];
 441 int matchGame = 0;
 442 TimeMark programStartTime;
 443 char ics_handle[MSG_SIZ];
 444 int have_set_title = 0;
 445
 446 /* animateTraining preserves the state of appData.animate
 447  * when Training mode is activated. This allows the
 448  * response to be animated when appData.animate == TRUE and
 449  * appData.animateDragging == TRUE.
 450  */
 451 Boolean animateTraining;
 452
 453 GameInfo gameInfo;
 454
 455 AppData appData;
 456
 457 Board boards[MAX_MOVES];
 458 /* [HGM] Following 7 needed for accurate legality tests: */
 459 signed char  castlingRank[BOARD_FILES]; // and corresponding ranks
 460 signed char  initialRights[BOARD_FILES];
 461 int   nrCastlingRights; // For TwoKings, or to implement castling-unknown status
 462 int   initialRulePlies, FENrulePlies;
 463 FILE  *serverMoves = NULL; // next two for broadcasting (/serverMoves option)
 464 int loadFlag = 0;
 465 int shuffleOpenings;
 466 int mute; // mute all sounds
 467
 468 // [HGM] vari: next 12 to save and restore variations
 469 #define MAX_VARIATIONS 10
 470 int framePtr = MAX_MOVES-1; // points to free stack entry
 471 int storedGames = 0;
 472 int savedFirst[MAX_VARIATIONS];
 473 int savedLast[MAX_VARIATIONS];
 474 int savedFramePtr[MAX_VARIATIONS];
 475 char *savedDetails[MAX_VARIATIONS];
 476 ChessMove savedResult[MAX_VARIATIONS];
 477
 478 void PushTail P((int firstMove, int lastMove));
 479 Boolean PopTail P((Boolean annotate));
 480 void CleanupTail P((void));
 481
 482 ChessSquare  FIDEArray[2][BOARD_FILES] = {
 483     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 484         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 485     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 486         BlackKing, BlackBishop, BlackKnight, BlackRook }
 487 };
 488
 489 ChessSquare twoKingsArray[2][BOARD_FILES] = {
 490     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 491         WhiteKing, WhiteKing, WhiteKnight, WhiteRook },
 492     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 493         BlackKing, BlackKing, BlackKnight, BlackRook }
 494 };
 495
 496 ChessSquare  KnightmateArray[2][BOARD_FILES] = {
 497     { WhiteRook, WhiteMan, WhiteBishop, WhiteQueen,
 498         WhiteUnicorn, WhiteBishop, WhiteMan, WhiteRook },
 499     { BlackRook, BlackMan, BlackBishop, BlackQueen,
 500         BlackUnicorn, BlackBishop, BlackMan, BlackRook }
 501 };
 502
 503 ChessSquare fairyArray[2][BOARD_FILES] = { /* [HGM] Queen side differs from King side */
 504     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 505         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 506     { BlackLance, BlackAlfil, BlackMarshall, BlackAngel,
 507         BlackKing, BlackMarshall, BlackAlfil, BlackLance }
 508 };
 509
 510 ChessSquare ShatranjArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 511     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteKing,
 512         WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 513     { BlackRook, BlackKnight, BlackAlfil, BlackKing,
 514         BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 515 };
 516
 517 ChessSquare makrukArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 518     { WhiteRook, WhiteKnight, WhiteMan, WhiteKing,
 519         WhiteFerz, WhiteMan, WhiteKnight, WhiteRook },
 520     { BlackRook, BlackKnight, BlackMan, BlackFerz,
 521         BlackKing, BlackMan, BlackKnight, BlackRook }
 522 };
 523
 524
 525 #if (BOARD_FILES>=10)
 526 ChessSquare ShogiArray[2][BOARD_FILES] = {
 527     { WhiteQueen, WhiteKnight, WhiteFerz, WhiteWazir,
 528         WhiteKing, WhiteWazir, WhiteFerz, WhiteKnight, WhiteQueen },
 529     { BlackQueen, BlackKnight, BlackFerz, BlackWazir,
 530         BlackKing, BlackWazir, BlackFerz, BlackKnight, BlackQueen }
 531 };
 532
 533 ChessSquare XiangqiArray[2][BOARD_FILES] = {
 534     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteFerz,
 535         WhiteWazir, WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 536     { BlackRook, BlackKnight, BlackAlfil, BlackFerz,
 537         BlackWazir, BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 538 };
 539
 540 ChessSquare CapablancaArray[2][BOARD_FILES] = {
 541     { WhiteRook, WhiteKnight, WhiteAngel, WhiteBishop, WhiteQueen,
 542         WhiteKing, WhiteBishop, WhiteMarshall, WhiteKnight, WhiteRook },
 543     { BlackRook, BlackKnight, BlackAngel, BlackBishop, BlackQueen,
 544         BlackKing, BlackBishop, BlackMarshall, BlackKnight, BlackRook }
 545 };
 546
 547 ChessSquare GreatArray[2][BOARD_FILES] = {
 548     { WhiteDragon, WhiteKnight, WhiteAlfil, WhiteGrasshopper, WhiteKing,
 549         WhiteSilver, WhiteCardinal, WhiteAlfil, WhiteKnight, WhiteDragon },
 550     { BlackDragon, BlackKnight, BlackAlfil, BlackGrasshopper, BlackKing,
 551         BlackSilver, BlackCardinal, BlackAlfil, BlackKnight, BlackDragon },
 552 };
 553
 554 ChessSquare JanusArray[2][BOARD_FILES] = {
 555     { WhiteRook, WhiteAngel, WhiteKnight, WhiteBishop, WhiteKing,
 556         WhiteQueen, WhiteBishop, WhiteKnight, WhiteAngel, WhiteRook },
 557     { BlackRook, BlackAngel, BlackKnight, BlackBishop, BlackKing,
 558         BlackQueen, BlackBishop, BlackKnight, BlackAngel, BlackRook }
 559 };
 560
 561 #ifdef GOTHIC
 562 ChessSquare GothicArray[2][BOARD_FILES] = {
 563     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen, WhiteMarshall,
 564         WhiteKing, WhiteAngel, WhiteBishop, WhiteKnight, WhiteRook },
 565     { BlackRook, BlackKnight, BlackBishop, BlackQueen, BlackMarshall,
 566         BlackKing, BlackAngel, BlackBishop, BlackKnight, BlackRook }
 567 };
 568 #else // !GOTHIC
 569 #define GothicArray CapablancaArray
 570 #endif // !GOTHIC
 571
 572 #ifdef FALCON
 573 ChessSquare FalconArray[2][BOARD_FILES] = {
 574     { WhiteRook, WhiteKnight, WhiteBishop, WhiteLance, WhiteQueen,
 575         WhiteKing, WhiteLance, WhiteBishop, WhiteKnight, WhiteRook },
 576     { BlackRook, BlackKnight, BlackBishop, BlackLance, BlackQueen,
 577         BlackKing, BlackLance, BlackBishop, BlackKnight, BlackRook }
 578 };
 579 #else // !FALCON
 580 #define FalconArray CapablancaArray
 581 #endif // !FALCON
 582
 583 #else // !(BOARD_FILES>=10)
 584 #define XiangqiPosition FIDEArray
 585 #define CapablancaArray FIDEArray
 586 #define GothicArray FIDEArray
 587 #define GreatArray FIDEArray
 588 #endif // !(BOARD_FILES>=10)
 589
 590 #if (BOARD_FILES>=12)
 591 ChessSquare CourierArray[2][BOARD_FILES] = {
 592     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteBishop, WhiteMan, WhiteKing,
 593         WhiteFerz, WhiteWazir, WhiteBishop, WhiteAlfil, WhiteKnight, WhiteRook },
 594     { BlackRook, BlackKnight, BlackAlfil, BlackBishop, BlackMan, BlackKing,
 595         BlackFerz, BlackWazir, BlackBishop, BlackAlfil, BlackKnight, BlackRook }
 596 };
 597 #else // !(BOARD_FILES>=12)
 598 #define CourierArray CapablancaArray
 599 #endif // !(BOARD_FILES>=12)
 600
 601
 602 Board initialPosition;
 603
 604
 605 /* Convert str to a rating. Checks for special cases of "----",
 606
 607    "++++", etc. Also strips ()'s */
 608 int
 609 string_to_rating(str)
 610   char *str;
 611 {
 612   while(*str && !isdigit(*str)) ++str;
 613   if (!*str)
 614     return 0;   /* One of the special "no rating" cases */
 615   else
 616     return atoi(str);
 617 }
 618
 619 void
 620 ClearProgramStats()
 621 {
 622     /* Init programStats */
 623     programStats.movelist[0] = 0;
 624     programStats.depth = 0;
 625     programStats.nr_moves = 0;
 626     programStats.moves_left = 0;
 627     programStats.nodes = 0;
 628     programStats.time = -1;        // [HGM] PGNtime: make invalid to recognize engine output
 629     programStats.score = 0;
 630     programStats.got_only_move = 0;
 631     programStats.got_fail = 0;
 632     programStats.line_is_book = 0;
 633 }
 634
 635 void
 636 InitBackEnd1()
 637 {
 638     int matched, min, sec;
 639
 640     ShowThinkingEvent(); // [HGM] thinking: make sure post/nopost state is set according to options
 641     startVariant = StringToVariant(appData.variant); // [HGM] nicks: remember original variant
 642
 643     GetTimeMark(&programStartTime);
 644     srandom((programStartTime.ms + 1000*programStartTime.sec)*0x1001001); // [HGM] book: makes sure random is unpredictabe to msec level
 645
 646     ClearProgramStats();
 647     programStats.ok_to_send = 1;
 648     programStats.seen_stat = 0;
 649
 650     /*
 651      * Initialize game list
 652      */
 653     ListNew(&gameList);
 654
 655
 656     /*
 657      * Internet chess server status
 658      */
 659     if (appData.icsActive) {
 660         appData.matchMode = FALSE;
 661         appData.matchGames = 0;
 662 #if ZIPPY
 663         appData.noChessProgram = !appData.zippyPlay;
 664 #else
 665         appData.zippyPlay = FALSE;
 666         appData.zippyTalk = FALSE;
 667         appData.noChessProgram = TRUE;
 668 #endif
 669         if (*appData.icsHelper != NULLCHAR) {
 670             appData.useTelnet = TRUE;
 671             appData.telnetProgram = appData.icsHelper;
 672         }
 673     } else {
 674         appData.zippyTalk = appData.zippyPlay = FALSE;
 675     }
 676
 677     /* [AS] Initialize pv info list [HGM] and game state */
 678     {
 679         int i, j;
 680
 681         for( i=0; i<=framePtr; i++ ) {
 682             pvInfoList[i].depth = -1;
 683             boards[i][EP_STATUS] = EP_NONE;
 684             for( j=0; j<BOARD_FILES-2; j++ ) boards[i][CASTLING][j] = NoRights;
 685         }
 686     }
 687
 688     /*
 689      * Parse timeControl resource
 690      */
 691     if (!ParseTimeControl(appData.timeControl, appData.timeIncrement,
 692                           appData.movesPerSession)) {
 693         char buf[MSG_SIZ];
 694         snprintf(buf, sizeof(buf), _("bad timeControl option %s"), appData.timeControl);
 695         DisplayFatalError(buf, 0, 2);
 696     }
 697
 698     /*
 699      * Parse searchTime resource
 700      */
 701     if (*appData.searchTime != NULLCHAR) {
 702         matched = sscanf(appData.searchTime, "%d:%d", &min, &sec);
 703         if (matched == 1) {
 704             searchTime = min * 60;
 705         } else if (matched == 2) {
 706             searchTime = min * 60 + sec;
 707         } else {
 708             char buf[MSG_SIZ];
 709             snprintf(buf, sizeof(buf), _("bad searchTime option %s"), appData.searchTime);
 710             DisplayFatalError(buf, 0, 2);
 711         }
 712     }
 713
 714     /* [AS] Adjudication threshold */
 715     adjudicateLossThreshold = appData.adjudicateLossThreshold;
 716
 717     first.which = "first";
 718     second.which = "second";
 719     first.maybeThinking = second.maybeThinking = FALSE;
 720     first.pr = second.pr = NoProc;
 721     first.isr = second.isr = NULL;
 722     first.sendTime = second.sendTime = 2;
 723     first.sendDrawOffers = 1;
 724     if (appData.firstPlaysBlack) {
 725         first.twoMachinesColor = "black\n";
 726         second.twoMachinesColor = "white\n";
 727     } else {
 728         first.twoMachinesColor = "white\n";
 729         second.twoMachinesColor = "black\n";
 730     }
 731     first.program = appData.firstChessProgram;
 732     second.program = appData.secondChessProgram;
 733     first.host = appData.firstHost;
 734     second.host = appData.secondHost;
 735     first.dir = appData.firstDirectory;
 736     second.dir = appData.secondDirectory;
 737     first.other = &second;
 738     second.other = &first;
 739     first.initString = appData.initString;
 740     second.initString = appData.secondInitString;
 741     first.computerString = appData.firstComputerString;
 742     second.computerString = appData.secondComputerString;
 743     first.useSigint = second.useSigint = TRUE;
 744     first.useSigterm = second.useSigterm = TRUE;
 745     first.reuse = appData.reuseFirst;
 746     second.reuse = appData.reuseSecond;
 747     first.nps = appData.firstNPS;   // [HGM] nps: copy nodes per second
 748     second.nps = appData.secondNPS;
 749     first.useSetboard = second.useSetboard = FALSE;
 750     first.useSAN = second.useSAN = FALSE;
 751     first.usePing = second.usePing = FALSE;
 752     first.lastPing = second.lastPing = 0;
 753     first.lastPong = second.lastPong = 0;
 754     first.usePlayother = second.usePlayother = FALSE;
 755     first.useColors = second.useColors = TRUE;
 756     first.useUsermove = second.useUsermove = FALSE;
 757     first.sendICS = second.sendICS = FALSE;
 758     first.sendName = second.sendName = appData.icsActive;
 759     first.sdKludge = second.sdKludge = FALSE;
 760     first.stKludge = second.stKludge = FALSE;
 761     TidyProgramName(first.program, first.host, first.tidy);
 762     TidyProgramName(second.program, second.host, second.tidy);
 763     first.matchWins = second.matchWins = 0;
 764     strcpy(first.variants, appData.variant);
 765     strcpy(second.variants, appData.variant);
 766     first.analysisSupport = second.analysisSupport = 2; /* detect */
 767     first.analyzing = second.analyzing = FALSE;
 768     first.initDone = second.initDone = FALSE;
 769
 770     /* New features added by Tord: */
 771     first.useFEN960 = FALSE; second.useFEN960 = FALSE;
 772     first.useOOCastle = TRUE; second.useOOCastle = TRUE;
 773     /* End of new features added by Tord. */
 774     first.fenOverride  = appData.fenOverride1;
 775     second.fenOverride = appData.fenOverride2;
 776
 777     /* [HGM] time odds: set factor for each machine */
 778     first.timeOdds  = appData.firstTimeOdds;
 779     second.timeOdds = appData.secondTimeOdds;
 780     { float norm = 1;
 781         if(appData.timeOddsMode) {
 782             norm = first.timeOdds;
 783             if(norm > second.timeOdds) norm = second.timeOdds;
 784         }
 785         first.timeOdds /= norm;
 786         second.timeOdds /= norm;
 787     }
 788
 789     /* [HGM] secondary TC: how to handle sessions that do not fit in 'level'*/
 790     first.accumulateTC = appData.firstAccumulateTC;
 791     second.accumulateTC = appData.secondAccumulateTC;
 792     first.maxNrOfSessions = second.maxNrOfSessions = 1;
 793
 794     /* [HGM] debug */
 795     first.debug = second.debug = FALSE;
 796     first.supportsNPS = second.supportsNPS = UNKNOWN;
 797
 798     /* [HGM] options */
 799     first.optionSettings  = appData.firstOptions;
 800     second.optionSettings = appData.secondOptions;
 801
 802     first.scoreIsAbsolute = appData.firstScoreIsAbsolute; /* [AS] */
 803     second.scoreIsAbsolute = appData.secondScoreIsAbsolute; /* [AS] */
 804     first.isUCI = appData.firstIsUCI; /* [AS] */
 805     second.isUCI = appData.secondIsUCI; /* [AS] */
 806     first.hasOwnBookUCI = appData.firstHasOwnBookUCI; /* [AS] */
 807     second.hasOwnBookUCI = appData.secondHasOwnBookUCI; /* [AS] */
 808
 809     if (appData.firstProtocolVersion > PROTOVER ||
 810         appData.firstProtocolVersion < 1) {
 811       char buf[MSG_SIZ];
 812       sprintf(buf, _("protocol version %d not supported"),
 813               appData.firstProtocolVersion);
 814       DisplayFatalError(buf, 0, 2);
 815     } else {
 816       first.protocolVersion = appData.firstProtocolVersion;
 817     }
 818
 819     if (appData.secondProtocolVersion > PROTOVER ||
 820         appData.secondProtocolVersion < 1) {
 821       char buf[MSG_SIZ];
 822       sprintf(buf, _("protocol version %d not supported"),
 823               appData.secondProtocolVersion);
 824       DisplayFatalError(buf, 0, 2);
 825     } else {
 826       second.protocolVersion = appData.secondProtocolVersion;
 827     }
 828
 829     if (appData.icsActive) {
 830         appData.clockMode = TRUE;  /* changes dynamically in ICS mode */
 831 //    } else if (*appData.searchTime != NULLCHAR || appData.noChessProgram) {
 832     } else if (appData.noChessProgram) { // [HGM] st: searchTime mode now also is clockMode
 833         appData.clockMode = FALSE;
 834         first.sendTime = second.sendTime = 0;
 835     }
 836
 837 #if ZIPPY
 838     /* Override some settings from environment variables, for backward
 839        compatibility.  Unfortunately it's not feasible to have the env
 840        vars just set defaults, at least in xboard.  Ugh.
 841     */
 842     if (appData.icsActive && (appData.zippyPlay || appData.zippyTalk)) {
 843       ZippyInit();
 844     }
 845 #endif
 846
 847     if (appData.noChessProgram) {
 848         programVersion = (char*) malloc(5 + strlen(PACKAGE_STRING));
 849         sprintf(programVersion, "%s", PACKAGE_STRING);
 850     } else {
 851       /* [HGM] tidy: use tidy name, in stead of full pathname (which was probably a bug due to / vs \ ) */
 852       programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
 853       sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
 854     }
 855
 856     if (!appData.icsActive) {
 857       char buf[MSG_SIZ];
 858       /* Check for variants that are supported only in ICS mode,
 859          or not at all.  Some that are accepted here nevertheless
 860          have bugs; see comments below.
 861       */
 862       VariantClass variant = StringToVariant(appData.variant);
 863       switch (variant) {
 864       case VariantBughouse:     /* need four players and two boards */
 865       case VariantKriegspiel:   /* need to hide pieces and move details */
 866       /* case VariantFischeRandom: (Fabien: moved below) */
 867         sprintf(buf, _("Variant %s supported only in ICS mode"), appData.variant);
 868         DisplayFatalError(buf, 0, 2);
 869         return;
 870
 871       case VariantUnknown:
 872       case VariantLoadable:
 873       case Variant29:
 874       case Variant30:
 875       case Variant31:
 876       case Variant32:
 877       case Variant33:
 878       case Variant34:
 879       case Variant35:
 880       case Variant36:
 881       default:
 882         sprintf(buf, _("Unknown variant name %s"), appData.variant);
 883         DisplayFatalError(buf, 0, 2);
 884         return;
 885
 886       case VariantXiangqi:    /* [HGM] repetition rules not implemented */
 887       case VariantFairy:      /* [HGM] TestLegality definitely off! */
 888       case VariantGothic:     /* [HGM] should work */
 889       case VariantCapablanca: /* [HGM] should work */
 890       case VariantCourier:    /* [HGM] initial forced moves not implemented */
 891       case VariantShogi:      /* [HGM] drops not tested for legality */
 892       case VariantKnightmate: /* [HGM] should work */
 893       case VariantCylinder:   /* [HGM] untested */
 894       case VariantFalcon:     /* [HGM] untested */
 895       case VariantCrazyhouse: /* holdings not shown, ([HGM] fixed that!)
 896                                  offboard interposition not understood */
 897       case VariantNormal:     /* definitely works! */
 898       case VariantWildCastle: /* pieces not automatically shuffled */
 899       case VariantNoCastle:   /* pieces not automatically shuffled */
 900       case VariantFischeRandom: /* [HGM] works and shuffles pieces */
 901       case VariantLosers:     /* should work except for win condition,
 902                                  and doesn't know captures are mandatory */
 903       case VariantSuicide:    /* should work except for win condition,
 904                                  and doesn't know captures are mandatory */
 905       case VariantGiveaway:   /* should work except for win condition,
 906                                  and doesn't know captures are mandatory */
 907       case VariantTwoKings:   /* should work */
 908       case VariantAtomic:     /* should work except for win condition */
 909       case Variant3Check:     /* should work except for win condition */
 910       case VariantShatranj:   /* should work except for all win conditions */
 911       case VariantMakruk:     /* should work except for daw countdown */
 912       case VariantBerolina:   /* might work if TestLegality is off */
 913       case VariantCapaRandom: /* should work */
 914       case VariantJanus:      /* should work */
 915       case VariantSuper:      /* experimental */
 916       case VariantGreat:      /* experimental, requires legality testing to be off */
 917         break;
 918       }
 919     }
 920
 921     InitEngineUCI( installDir, &first );  // [HGM] moved here from winboard.c, to make available in xboard
 922     InitEngineUCI( installDir, &second );
 923 }
 924
 925 int NextIntegerFromString( char ** str, long * value )
 926 {
 927     int result = -1;
 928     char * s = *str;
 929
 930     while( *s == ' ' || *s == '\t' ) {
 931         s++;
 932     }
 933
 934     *value = 0;
 935
 936     if( *s >= '0' && *s <= '9' ) {
 937         while( *s >= '0' && *s <= '9' ) {
 938             *value = *value * 10 + (*s - '0');
 939             s++;
 940         }
 941
 942         result = 0;
 943     }
 944
 945     *str = s;
 946
 947     return result;
 948 }
 949
 950 int NextTimeControlFromString( char ** str, long * value )
 951 {
 952     long temp;
 953     int result = NextIntegerFromString( str, &temp );
 954
 955     if( result == 0 ) {
 956         *value = temp * 60; /* Minutes */
 957         if( **str == ':' ) {
 958             (*str)++;
 959             result = NextIntegerFromString( str, &temp );
 960             *value += temp; /* Seconds */
 961         }
 962     }
 963
 964     return result;
 965 }
 966
 967 int NextSessionFromString( char ** str, int *moves, long * tc, long *inc)
 968 {   /* [HGM] routine added to read '+moves/time' for secondary time control */
 969     int result = -1; long temp, temp2;
 970
 971     if(**str != '+') return -1; // old params remain in force!
 972     (*str)++;
 973     if( NextTimeControlFromString( str, &temp ) ) return -1;
 974
 975     if(**str != '/') {
 976         /* time only: incremental or sudden-death time control */
 977         if(**str == '+') { /* increment follows; read it */
 978             (*str)++;
 979             if(result = NextIntegerFromString( str, &temp2)) return -1;
 980             *inc = temp2 * 1000;
 981         } else *inc = 0;
 982         *moves = 0; *tc = temp * 1000;
 983         return 0;
 984     } else if(temp % 60 != 0) return -1;     /* moves was given as min:sec */
 985
 986     (*str)++; /* classical time control */
 987     result = NextTimeControlFromString( str, &temp2);
 988     if(result == 0) {
 989         *moves = temp/60;
 990         *tc    = temp2 * 1000;
 991         *inc   = 0;
 992     }
 993     return result;
 994 }
 995
 996 int GetTimeQuota(int movenr)
 997 {   /* [HGM] get time to add from the multi-session time-control string */
 998     int moves=1; /* kludge to force reading of first session */
 999     long time, increment;
1000     char *s = fullTimeControlString;
1001
1002     if(appData.debugMode) fprintf(debugFP, "TC string = '%s'\n", fullTimeControlString);
1003     do {
1004         if(moves) NextSessionFromString(&s, &moves, &time, &increment);
1005         if(appData.debugMode) fprintf(debugFP, "mps=%d tc=%d inc=%d\n", moves, (int) time, (int) increment);
1006         if(movenr == -1) return time;    /* last move before new session     */
1007         if(!moves) return increment;     /* current session is incremental   */
1008         if(movenr >= 0) movenr -= moves; /* we already finished this session */
1009     } while(movenr >= -1);               /* try again for next session       */
1010
1011     return 0; // no new time quota on this move
1012 }
1013
1014 int
1015 ParseTimeControl(tc, ti, mps)
1016      char *tc;
1017      int ti;
1018      int mps;
1019 {
1020   long tc1;
1021   long tc2;
1022   char buf[MSG_SIZ];
1023
1024   if(ti >= 0 && !strchr(tc, '+') && !strchr(tc, '/') ) mps = 0;
1025   if(ti > 0) {
1026     if(mps)
1027       sprintf(buf, "+%d/%s+%d", mps, tc, ti);
1028     else sprintf(buf, "+%s+%d", tc, ti);
1029   } else {
1030     if(mps)
1031              sprintf(buf, "+%d/%s", mps, tc);
1032     else sprintf(buf, "+%s", tc);
1033   }
1034   fullTimeControlString = StrSave(buf);
1035
1036   if( NextTimeControlFromString( &tc, &tc1 ) != 0 ) {
1037     return FALSE;
1038   }
1039
1040   if( *tc == '/' ) {
1041     /* Parse second time control */
1042     tc++;
1043
1044     if( NextTimeControlFromString( &tc, &tc2 ) != 0 ) {
1045       return FALSE;
1046     }
1047
1048     if( tc2 == 0 ) {
1049       return FALSE;
1050     }
1051
1052     timeControl_2 = tc2 * 1000;
1053   }
1054   else {
1055     timeControl_2 = 0;
1056   }
1057
1058   if( tc1 == 0 ) {
1059     return FALSE;
1060   }
1061
1062   timeControl = tc1 * 1000;
1063
1064   if (ti >= 0) {
1065     timeIncrement = ti * 1000;  /* convert to ms */
1066     movesPerSession = 0;
1067   } else {
1068     timeIncrement = 0;
1069     movesPerSession = mps;
1070   }
1071   return TRUE;
1072 }
1073
1074 void
1075 InitBackEnd2()
1076 {
1077     if (appData.debugMode) {
1078         fprintf(debugFP, "%s\n", programVersion);
1079     }
1080
1081     set_cont_sequence(appData.wrapContSeq);
1082     if (appData.matchGames > 0) {
1083         appData.matchMode = TRUE;
1084     } else if (appData.matchMode) {
1085         appData.matchGames = 1;
1086     }
1087     if(appData.matchMode && appData.sameColorGames > 0) /* [HGM] alternate: overrule matchGames */
1088         appData.matchGames = appData.sameColorGames;
1089     if(appData.rewindIndex > 1) { /* [HGM] autoinc: rewind implies auto-increment and overrules given index */
1090         if(appData.loadPositionIndex >= 0) appData.loadPositionIndex = -1;
1091         if(appData.loadGameIndex >= 0) appData.loadGameIndex = -1;
1092     }
1093     Reset(TRUE, FALSE);
1094     if (appData.noChessProgram || first.protocolVersion == 1) {
1095       InitBackEnd3();
1096     } else {
1097       /* kludge: allow timeout for initial "feature" commands */
1098       FreezeUI();
1099       DisplayMessage("", _("Starting chess program"));
1100       ScheduleDelayedEvent(InitBackEnd3, FEATURE_TIMEOUT);
1101     }
1102 }
1103
1104 void
1105 InitBackEnd3 P((void))
1106 {
1107     GameMode initialMode;
1108     char buf[MSG_SIZ];
1109     int err;
1110
1111     InitChessProgram(&first, startedFromSetupPosition);
1112
1113     if(!appData.noChessProgram) {  /* [HGM] tidy: redo program version to use name from myname feature */
1114         free(programVersion);
1115         programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
1116         sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
1117     }
1118
1119     if (appData.icsActive) {
1120 #ifdef WIN32
1121         /* [DM] Make a console window if needed [HGM] merged ifs */
1122         ConsoleCreate();
1123 #endif
1124         err = establish();
1125         if (err != 0) {
1126             if (*appData.icsCommPort != NULLCHAR) {
1127                 sprintf(buf, _("Could not open comm port %s"),
1128                         appData.icsCommPort);
1129             } else {
1130                 snprintf(buf, sizeof(buf), _("Could not connect to host %s, port %s"),
1131                         appData.icsHost, appData.icsPort);
1132             }
1133             DisplayFatalError(buf, err, 1);
1134             return;
1135         }
1136         SetICSMode();
1137         telnetISR =
1138           AddInputSource(icsPR, FALSE, read_from_ics, &telnetISR);
1139         fromUserISR =
1140           AddInputSource(NoProc, FALSE, read_from_player, &fromUserISR);
1141         if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
1142             ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1143     } else if (appData.noChessProgram) {
1144         SetNCPMode();
1145     } else {
1146         SetGNUMode();
1147     }
1148
1149     if (*appData.cmailGameName != NULLCHAR) {
1150         SetCmailMode();
1151         OpenLoopback(&cmailPR);
1152         cmailISR =
1153           AddInputSource(cmailPR, FALSE, CmailSigHandlerCallBack, &cmailISR);
1154     }
1155
1156     ThawUI();
1157     DisplayMessage("", "");
1158     if (StrCaseCmp(appData.initialMode, "") == 0) {
1159       initialMode = BeginningOfGame;
1160     } else if (StrCaseCmp(appData.initialMode, "TwoMachines") == 0) {
1161       initialMode = TwoMachinesPlay;
1162     } else if (StrCaseCmp(appData.initialMode, "AnalyzeFile") == 0) {
1163       initialMode = AnalyzeFile;
1164     } else if (StrCaseCmp(appData.initialMode, "Analysis") == 0) {
1165       initialMode = AnalyzeMode;
1166     } else if (StrCaseCmp(appData.initialMode, "MachineWhite") == 0) {
1167       initialMode = MachinePlaysWhite;
1168     } else if (StrCaseCmp(appData.initialMode, "MachineBlack") == 0) {
1169       initialMode = MachinePlaysBlack;
1170     } else if (StrCaseCmp(appData.initialMode, "EditGame") == 0) {
1171       initialMode = EditGame;
1172     } else if (StrCaseCmp(appData.initialMode, "EditPosition") == 0) {
1173       initialMode = EditPosition;
1174     } else if (StrCaseCmp(appData.initialMode, "Training") == 0) {
1175       initialMode = Training;
1176     } else {
1177       sprintf(buf, _("Unknown initialMode %s"), appData.initialMode);
1178       DisplayFatalError(buf, 0, 2);
1179       return;
1180     }
1181
1182     if (appData.matchMode) {
1183         /* Set up machine vs. machine match */
1184         if (appData.noChessProgram) {
1185             DisplayFatalError(_("Can't have a match with no chess programs"),
1186                               0, 2);
1187             return;
1188         }
1189         matchMode = TRUE;
1190         matchGame = 1;
1191         if (*appData.loadGameFile != NULLCHAR) {
1192             int index = appData.loadGameIndex; // [HGM] autoinc
1193             if(index<0) lastIndex = index = 1;
1194             if (!LoadGameFromFile(appData.loadGameFile,
1195                                   index,
1196                                   appData.loadGameFile, FALSE)) {
1197                 DisplayFatalError(_("Bad game file"), 0, 1);
1198                 return;
1199             }
1200         } else if (*appData.loadPositionFile != NULLCHAR) {
1201             int index = appData.loadPositionIndex; // [HGM] autoinc
1202             if(index<0) lastIndex = index = 1;
1203             if (!LoadPositionFromFile(appData.loadPositionFile,
1204                                       index,
1205                                       appData.loadPositionFile)) {
1206                 DisplayFatalError(_("Bad position file"), 0, 1);
1207                 return;
1208             }
1209         }
1210         TwoMachinesEvent();
1211     } else if (*appData.cmailGameName != NULLCHAR) {
1212         /* Set up cmail mode */
1213         ReloadCmailMsgEvent(TRUE);
1214     } else {
1215         /* Set up other modes */
1216         if (initialMode == AnalyzeFile) {
1217           if (*appData.loadGameFile == NULLCHAR) {
1218             DisplayFatalError(_("AnalyzeFile mode requires a game file"), 0, 1);
1219             return;
1220           }
1221         }
1222         if (*appData.loadGameFile != NULLCHAR) {
1223             (void) LoadGameFromFile(appData.loadGameFile,
1224                                     appData.loadGameIndex,
1225                                     appData.loadGameFile, TRUE);
1226         } else if (*appData.loadPositionFile != NULLCHAR) {
1227             (void) LoadPositionFromFile(appData.loadPositionFile,
1228                                         appData.loadPositionIndex,
1229                                         appData.loadPositionFile);
1230             /* [HGM] try to make self-starting even after FEN load */
1231             /* to allow automatic setup of fairy variants with wtm */
1232             if(initialMode == BeginningOfGame && !blackPlaysFirst) {
1233                 gameMode = BeginningOfGame;
1234                 setboardSpoiledMachineBlack = 1;
1235             }
1236             /* [HGM] loadPos: make that every new game uses the setup */
1237             /* from file as long as we do not switch variant          */
1238             if(!blackPlaysFirst) {
1239                 startedFromPositionFile = TRUE;
1240                 CopyBoard(filePosition, boards[0]);
1241             }
1242         }
1243         if (initialMode == AnalyzeMode) {
1244           if (appData.noChessProgram) {
1245             DisplayFatalError(_("Analysis mode requires a chess engine"), 0, 2);
1246             return;
1247           }
1248           if (appData.icsActive) {
1249             DisplayFatalError(_("Analysis mode does not work with ICS mode"),0,2);
1250             return;
1251           }
1252           AnalyzeModeEvent();
1253         } else if (initialMode == AnalyzeFile) {
1254           appData.showThinking = TRUE; // [HGM] thinking: moved out of ShowThinkingEvent
1255           ShowThinkingEvent();
1256           AnalyzeFileEvent();
1257           AnalysisPeriodicEvent(1);
1258         } else if (initialMode == MachinePlaysWhite) {
1259           if (appData.noChessProgram) {
1260             DisplayFatalError(_("MachineWhite mode requires a chess engine"),
1261                               0, 2);
1262             return;
1263           }
1264           if (appData.icsActive) {
1265             DisplayFatalError(_("MachineWhite mode does not work with ICS mode"),
1266                               0, 2);
1267             return;
1268           }
1269           MachineWhiteEvent();
1270         } else if (initialMode == MachinePlaysBlack) {
1271           if (appData.noChessProgram) {
1272             DisplayFatalError(_("MachineBlack mode requires a chess engine"),
1273                               0, 2);
1274             return;
1275           }
1276           if (appData.icsActive) {
1277             DisplayFatalError(_("MachineBlack mode does not work with ICS mode"),
1278                               0, 2);
1279             return;
1280           }
1281           MachineBlackEvent();
1282         } else if (initialMode == TwoMachinesPlay) {
1283           if (appData.noChessProgram) {
1284             DisplayFatalError(_("TwoMachines mode requires a chess engine"),
1285                               0, 2);
1286             return;
1287           }
1288           if (appData.icsActive) {
1289             DisplayFatalError(_("TwoMachines mode does not work with ICS mode"),
1290                               0, 2);
1291             return;
1292           }
1293           TwoMachinesEvent();
1294         } else if (initialMode == EditGame) {
1295           EditGameEvent();
1296         } else if (initialMode == EditPosition) {
1297           EditPositionEvent();
1298         } else if (initialMode == Training) {
1299           if (*appData.loadGameFile == NULLCHAR) {
1300             DisplayFatalError(_("Training mode requires a game file"), 0, 2);
1301             return;
1302           }
1303           TrainingEvent();
1304         }
1305     }
1306 }
1307
1308 /*
1309  * Establish will establish a contact to a remote host.port.
1310  * Sets icsPR to a ProcRef for a process (or pseudo-process)
1311  *  used to talk to the host.
1312  * Returns 0 if okay, error code if not.
1313  */
1314 int
1315 establish()
1316 {
1317     char buf[MSG_SIZ];
1318
1319     if (*appData.icsCommPort != NULLCHAR) {
1320         /* Talk to the host through a serial comm port */
1321         return OpenCommPort(appData.icsCommPort, &icsPR);
1322
1323     } else if (*appData.gateway != NULLCHAR) {
1324         if (*appData.remoteShell == NULLCHAR) {
1325             /* Use the rcmd protocol to run telnet program on a gateway host */
1326             snprintf(buf, sizeof(buf), "%s %s %s",
1327                     appData.telnetProgram, appData.icsHost, appData.icsPort);
1328             return OpenRcmd(appData.gateway, appData.remoteUser, buf, &icsPR);
1329
1330         } else {
1331             /* Use the rsh program to run telnet program on a gateway host */
1332             if (*appData.remoteUser == NULLCHAR) {
1333                 snprintf(buf, sizeof(buf), "%s %s %s %s %s", appData.remoteShell,
1334                         appData.gateway, appData.telnetProgram,
1335                         appData.icsHost, appData.icsPort);
1336             } else {
1337                 snprintf(buf, sizeof(buf), "%s %s -l %s %s %s %s",
1338                         appData.remoteShell, appData.gateway,
1339                         appData.remoteUser, appData.telnetProgram,
1340                         appData.icsHost, appData.icsPort);
1341             }
1342             return StartChildProcess(buf, "", &icsPR);
1343
1344         }
1345     } else if (appData.useTelnet) {
1346         return OpenTelnet(appData.icsHost, appData.icsPort, &icsPR);
1347
1348     } else {
1349         /* TCP socket interface differs somewhat between
1350            Unix and NT; handle details in the front end.
1351            */
1352         return OpenTCP(appData.icsHost, appData.icsPort, &icsPR);
1353     }
1354 }
1355
1356 void EscapeExpand(char *p, char *q)
1357 {       // [HGM] initstring: routine to shape up string arguments
1358         while(*p++ = *q++) if(p[-1] == '\\')
1359             switch(*q++) {
1360                 case 'n': p[-1] = '\n'; break;
1361                 case 'r': p[-1] = '\r'; break;
1362                 case 't': p[-1] = '\t'; break;
1363                 case '\\': p[-1] = '\\'; break;
1364                 case 0: *p = 0; return;
1365                 default: p[-1] = q[-1]; break;
1366             }
1367 }
1368
1369 void
1370 show_bytes(fp, buf, count)
1371      FILE *fp;
1372      char *buf;
1373      int count;
1374 {
1375     while (count--) {
1376         if (*buf < 040 || *(unsigned char *) buf > 0177) {
1377             fprintf(fp, "\\%03o", *buf & 0xff);
1378         } else {
1379             putc(*buf, fp);
1380         }
1381         buf++;
1382     }
1383     fflush(fp);
1384 }
1385
1386 /* Returns an errno value */
1387 int
1388 OutputMaybeTelnet(pr, message, count, outError)
1389      ProcRef pr;
1390      char *message;
1391      int count;
1392      int *outError;
1393 {
1394     char buf[8192], *p, *q, *buflim;
1395     int left, newcount, outcount;
1396
1397     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet ||
1398         *appData.gateway != NULLCHAR) {
1399         if (appData.debugMode) {
1400             fprintf(debugFP, ">ICS: ");
1401             show_bytes(debugFP, message, count);
1402             fprintf(debugFP, "\n");
1403         }
1404         return OutputToProcess(pr, message, count, outError);
1405     }
1406
1407     buflim = &buf[sizeof(buf)-1]; /* allow 1 byte for expanding last char */
1408     p = message;
1409     q = buf;
1410     left = count;
1411     newcount = 0;
1412     while (left) {
1413         if (q >= buflim) {
1414             if (appData.debugMode) {
1415                 fprintf(debugFP, ">ICS: ");
1416                 show_bytes(debugFP, buf, newcount);
1417                 fprintf(debugFP, "\n");
1418             }
1419             outcount = OutputToProcess(pr, buf, newcount, outError);
1420             if (outcount < newcount) return -1; /* to be sure */
1421             q = buf;
1422             newcount = 0;
1423         }
1424         if (*p == '\n') {
1425             *q++ = '\r';
1426             newcount++;
1427         } else if (((unsigned char) *p) == TN_IAC) {
1428             *q++ = (char) TN_IAC;
1429             newcount ++;
1430         }
1431         *q++ = *p++;
1432         newcount++;
1433         left--;
1434     }
1435     if (appData.debugMode) {
1436         fprintf(debugFP, ">ICS: ");
1437         show_bytes(debugFP, buf, newcount);
1438         fprintf(debugFP, "\n");
1439     }
1440     outcount = OutputToProcess(pr, buf, newcount, outError);
1441     if (outcount < newcount) return -1; /* to be sure */
1442     return count;
1443 }
1444
1445 void
1446 read_from_player(isr, closure, message, count, error)
1447      InputSourceRef isr;
1448      VOIDSTAR closure;
1449      char *message;
1450      int count;
1451      int error;
1452 {
1453     int outError, outCount;
1454     static int gotEof = 0;
1455
1456     /* Pass data read from player on to ICS */
1457     if (count > 0) {
1458         gotEof = 0;
1459         outCount = OutputMaybeTelnet(icsPR, message, count, &outError);
1460         if (outCount < count) {
1461             DisplayFatalError(_("Error writing to ICS"), outError, 1);
1462         }
1463     } else if (count < 0) {
1464         RemoveInputSource(isr);
1465         DisplayFatalError(_("Error reading from keyboard"), error, 1);
1466     } else if (gotEof++ > 0) {
1467         RemoveInputSource(isr);
1468         DisplayFatalError(_("Got end of file from keyboard"), 0, 0);
1469     }
1470 }
1471
1472 void
1473 KeepAlive()
1474 {   // [HGM] alive: periodically send dummy (date) command to ICS to prevent time-out
1475     if(!connectionAlive) DisplayFatalError("No response from ICS", 0, 1);
1476     connectionAlive = FALSE; // only sticks if no response to 'date' command.
1477     SendToICS("date\n");
1478     if(appData.keepAlive) ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1479 }
1480
1481 /* added routine for printf style output to ics */
1482 void ics_printf(char *format, ...)
1483 {
1484     char buffer[MSG_SIZ];
1485     va_list args;
1486
1487     va_start(args, format);
1488     vsnprintf(buffer, sizeof(buffer), format, args);
1489     buffer[sizeof(buffer)-1] = '\0';
1490     SendToICS(buffer);
1491     va_end(args);
1492 }
1493
1494 void
1495 SendToICS(s)
1496      char *s;
1497 {
1498     int count, outCount, outError;
1499
1500     if (icsPR == NULL) return;
1501
1502     count = strlen(s);
1503     outCount = OutputMaybeTelnet(icsPR, s, count, &outError);
1504     if (outCount < count) {
1505         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1506     }
1507 }
1508
1509 /* This is used for sending logon scripts to the ICS. Sending
1510    without a delay causes problems when using timestamp on ICC
1511    (at least on my machine). */
1512 void
1513 SendToICSDelayed(s,msdelay)
1514      char *s;
1515      long msdelay;
1516 {
1517     int count, outCount, outError;
1518
1519     if (icsPR == NULL) return;
1520
1521     count = strlen(s);
1522     if (appData.debugMode) {
1523         fprintf(debugFP, ">ICS: ");
1524         show_bytes(debugFP, s, count);
1525         fprintf(debugFP, "\n");
1526     }
1527     outCount = OutputToProcessDelayed(icsPR, s, count, &outError,
1528                                       msdelay);
1529     if (outCount < count) {
1530         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1531     }
1532 }
1533
1534
1535 /* Remove all highlighting escape sequences in s
1536    Also deletes any suffix starting with '('
1537    */
1538 char *
1539 StripHighlightAndTitle(s)
1540      char *s;
1541 {
1542     static char retbuf[MSG_SIZ];
1543     char *p = retbuf;
1544
1545     while (*s != NULLCHAR) {
1546         while (*s == '\033') {
1547             while (*s != NULLCHAR && !isalpha(*s)) s++;
1548             if (*s != NULLCHAR) s++;
1549         }
1550         while (*s != NULLCHAR && *s != '\033') {
1551             if (*s == '(' || *s == '[') {
1552                 *p = NULLCHAR;
1553                 return retbuf;
1554             }
1555             *p++ = *s++;
1556         }
1557     }
1558     *p = NULLCHAR;
1559     return retbuf;
1560 }
1561
1562 /* Remove all highlighting escape sequences in s */
1563 char *
1564 StripHighlight(s)
1565      char *s;
1566 {
1567     static char retbuf[MSG_SIZ];
1568     char *p = retbuf;
1569
1570     while (*s != NULLCHAR) {
1571         while (*s == '\033') {
1572             while (*s != NULLCHAR && !isalpha(*s)) s++;
1573             if (*s != NULLCHAR) s++;
1574         }
1575         while (*s != NULLCHAR && *s != '\033') {
1576             *p++ = *s++;
1577         }
1578     }
1579     *p = NULLCHAR;
1580     return retbuf;
1581 }
1582
1583 char *variantNames[] = VARIANT_NAMES;
1584 char *
1585 VariantName(v)
1586      VariantClass v;
1587 {
1588     return variantNames[v];
1589 }
1590
1591
1592 /* Identify a variant from the strings the chess servers use or the
1593    PGN Variant tag names we use. */
1594 VariantClass
1595 StringToVariant(e)
1596      char *e;
1597 {
1598     char *p;
1599     int wnum = -1;
1600     VariantClass v = VariantNormal;
1601     int i, found = FALSE;
1602     char buf[MSG_SIZ];
1603
1604     if (!e) return v;
1605
1606     /* [HGM] skip over optional board-size prefixes */
1607     if( sscanf(e, "%dx%d_", &i, &i) == 2 ||
1608         sscanf(e, "%dx%d+%d_", &i, &i, &i) == 3 ) {
1609         while( *e++ != '_');
1610     }
1611
1612     if(StrCaseStr(e, "misc/")) { // [HGM] on FICS, misc/shogi is not shogi
1613         v = VariantNormal;
1614         found = TRUE;
1615     } else
1616     for (i=0; i<sizeof(variantNames)/sizeof(char*); i++) {
1617       if (StrCaseStr(e, variantNames[i])) {
1618         v = (VariantClass) i;
1619         found = TRUE;
1620         break;
1621       }
1622     }
1623
1624     if (!found) {
1625       if ((StrCaseStr(e, "fischer") && StrCaseStr(e, "random"))
1626           || StrCaseStr(e, "wild/fr")
1627           || StrCaseStr(e, "frc") || StrCaseStr(e, "960")) {
1628         v = VariantFischeRandom;
1629       } else if ((i = 4, p = StrCaseStr(e, "wild")) ||
1630                  (i = 1, p = StrCaseStr(e, "w"))) {
1631         p += i;
1632         while (*p && (isspace(*p) || *p == '(' || *p == '/')) p++;
1633         if (isdigit(*p)) {
1634           wnum = atoi(p);
1635         } else {
1636           wnum = -1;
1637         }
1638         switch (wnum) {
1639         case 0: /* FICS only, actually */
1640         case 1:
1641           /* Castling legal even if K starts on d-file */
1642           v = VariantWildCastle;
1643           break;
1644         case 2:
1645         case 3:
1646         case 4:
1647           /* Castling illegal even if K & R happen to start in
1648              normal positions. */
1649           v = VariantNoCastle;
1650           break;
1651         case 5:
1652         case 7:
1653         case 8:
1654         case 10:
1655         case 11:
1656         case 12:
1657         case 13:
1658         case 14:
1659         case 15:
1660         case 18:
1661         case 19:
1662           /* Castling legal iff K & R start in normal positions */
1663           v = VariantNormal;
1664           break;
1665         case 6:
1666         case 20:
1667         case 21:
1668           /* Special wilds for position setup; unclear what to do here */
1669           v = VariantLoadable;
1670           break;
1671         case 9:
1672           /* Bizarre ICC game */
1673           v = VariantTwoKings;
1674           break;
1675         case 16:
1676           v = VariantKriegspiel;
1677           break;
1678         case 17:
1679           v = VariantLosers;
1680           break;
1681         case 22:
1682           v = VariantFischeRandom;
1683           break;
1684         case 23:
1685           v = VariantCrazyhouse;
1686           break;
1687         case 24:
1688           v = VariantBughouse;
1689           break;
1690         case 25:
1691           v = Variant3Check;
1692           break;
1693         case 26:
1694           /* Not quite the same as FICS suicide! */
1695           v = VariantGiveaway;
1696           break;
1697         case 27:
1698           v = VariantAtomic;
1699           break;
1700         case 28:
1701           v = VariantShatranj;
1702           break;
1703
1704         /* Temporary names for future ICC types.  The name *will* change in
1705            the next xboard/WinBoard release after ICC defines it. */
1706         case 29:
1707           v = Variant29;
1708           break;
1709         case 30:
1710           v = Variant30;
1711           break;
1712         case 31:
1713           v = Variant31;
1714           break;
1715         case 32:
1716           v = Variant32;
1717           break;
1718         case 33:
1719           v = Variant33;
1720           break;
1721         case 34:
1722           v = Variant34;
1723           break;
1724         case 35:
1725           v = Variant35;
1726           break;
1727         case 36:
1728           v = Variant36;
1729           break;
1730         case 37:
1731           v = VariantShogi;
1732           break;
1733         case 38:
1734           v = VariantXiangqi;
1735           break;
1736         case 39:
1737           v = VariantCourier;
1738           break;
1739         case 40:
1740           v = VariantGothic;
1741           break;
1742         case 41:
1743           v = VariantCapablanca;
1744           break;
1745         case 42:
1746           v = VariantKnightmate;
1747           break;
1748         case 43:
1749           v = VariantFairy;
1750           break;
1751         case 44:
1752           v = VariantCylinder;
1753           break;
1754         case 45:
1755           v = VariantFalcon;
1756           break;
1757         case 46:
1758           v = VariantCapaRandom;
1759           break;
1760         case 47:
1761           v = VariantBerolina;
1762           break;
1763         case 48:
1764           v = VariantJanus;
1765           break;
1766         case 49:
1767           v = VariantSuper;
1768           break;
1769         case 50:
1770           v = VariantGreat;
1771           break;
1772         case -1:
1773           /* Found "wild" or "w" in the string but no number;
1774              must assume it's normal chess. */
1775           v = VariantNormal;
1776           break;
1777         default:
1778           sprintf(buf, _("Unknown wild type %d"), wnum);
1779           DisplayError(buf, 0);
1780           v = VariantUnknown;
1781           break;
1782         }
1783       }
1784     }
1785     if (appData.debugMode) {
1786       fprintf(debugFP, _("recognized '%s' (%d) as variant %s\n"),
1787               e, wnum, VariantName(v));
1788     }
1789     return v;
1790 }
1791
1792 static int leftover_start = 0, leftover_len = 0;
1793 char star_match[STAR_MATCH_N][MSG_SIZ];
1794
1795 /* Test whether pattern is present at &buf[*index]; if so, return TRUE,
1796    advance *index beyond it, and set leftover_start to the new value of
1797    *index; else return FALSE.  If pattern contains the character '*', it
1798    matches any sequence of characters not containing '\r', '\n', or the
1799    character following the '*' (if any), and the matched sequence(s) are
1800    copied into star_match.
1801    */
1802 int
1803 looking_at(buf, index, pattern)
1804      char *buf;
1805      int *index;
1806      char *pattern;
1807 {
1808     char *bufp = &buf[*index], *patternp = pattern;
1809     int star_count = 0;
1810     char *matchp = star_match[0];
1811
1812     for (;;) {
1813         if (*patternp == NULLCHAR) {
1814             *index = leftover_start = bufp - buf;
1815             *matchp = NULLCHAR;
1816             return TRUE;
1817         }
1818         if (*bufp == NULLCHAR) return FALSE;
1819         if (*patternp == '*') {
1820             if (*bufp == *(patternp + 1)) {
1821                 *matchp = NULLCHAR;
1822                 matchp = star_match[++star_count];
1823                 patternp += 2;
1824                 bufp++;
1825                 continue;
1826             } else if (*bufp == '\n' || *bufp == '\r') {
1827                 patternp++;
1828                 if (*patternp == NULLCHAR)
1829                   continue;
1830                 else
1831                   return FALSE;
1832             } else {
1833                 *matchp++ = *bufp++;
1834                 continue;
1835             }
1836         }
1837         if (*patternp != *bufp) return FALSE;
1838         patternp++;
1839         bufp++;
1840     }
1841 }
1842
1843 void
1844 SendToPlayer(data, length)
1845      char *data;
1846      int length;
1847 {
1848     int error, outCount;
1849     outCount = OutputToProcess(NoProc, data, length, &error);
1850     if (outCount < length) {
1851         DisplayFatalError(_("Error writing to display"), error, 1);
1852     }
1853 }
1854
1855 void
1856 PackHolding(packed, holding)
1857      char packed[];
1858      char *holding;
1859 {
1860     char *p = holding;
1861     char *q = packed;
1862     int runlength = 0;
1863     int curr = 9999;
1864     do {
1865         if (*p == curr) {
1866             runlength++;
1867         } else {
1868             switch (runlength) {
1869               case 0:
1870                 break;
1871               case 1:
1872                 *q++ = curr;
1873                 break;
1874               case 2:
1875                 *q++ = curr;
1876                 *q++ = curr;
1877                 break;
1878               default:
1879                 sprintf(q, "%d", runlength);
1880                 while (*q) q++;
1881                 *q++ = curr;
1882                 break;
1883             }
1884             runlength = 1;
1885             curr = *p;
1886         }
1887     } while (*p++);
1888     *q = NULLCHAR;
1889 }
1890
1891 /* Telnet protocol requests from the front end */
1892 void
1893 TelnetRequest(ddww, option)
1894      unsigned char ddww, option;
1895 {
1896     unsigned char msg[3];
1897     int outCount, outError;
1898
1899     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet) return;
1900
1901     if (appData.debugMode) {
1902         char buf1[8], buf2[8], *ddwwStr, *optionStr;
1903         switch (ddww) {
1904           case TN_DO:
1905             ddwwStr = "DO";
1906             break;
1907           case TN_DONT:
1908             ddwwStr = "DONT";
1909             break;
1910           case TN_WILL:
1911             ddwwStr = "WILL";
1912             break;
1913           case TN_WONT:
1914             ddwwStr = "WONT";
1915             break;
1916           default:
1917             ddwwStr = buf1;
1918             sprintf(buf1, "%d", ddww);
1919             break;
1920         }
1921         switch (option) {
1922           case TN_ECHO:
1923             optionStr = "ECHO";
1924             break;
1925           default:
1926             optionStr = buf2;
1927             sprintf(buf2, "%d", option);
1928             break;
1929         }
1930         fprintf(debugFP, ">%s %s ", ddwwStr, optionStr);
1931     }
1932     msg[0] = TN_IAC;
1933     msg[1] = ddww;
1934     msg[2] = option;
1935     outCount = OutputToProcess(icsPR, (char *)msg, 3, &outError);
1936     if (outCount < 3) {
1937         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1938     }
1939 }
1940
1941 void
1942 DoEcho()
1943 {
1944     if (!appData.icsActive) return;
1945     TelnetRequest(TN_DO, TN_ECHO);
1946 }
1947
1948 void
1949 DontEcho()
1950 {
1951     if (!appData.icsActive) return;
1952     TelnetRequest(TN_DONT, TN_ECHO);
1953 }
1954
1955 void
1956 CopyHoldings(Board board, char *holdings, ChessSquare lowestPiece)
1957 {
1958     /* put the holdings sent to us by the server on the board holdings area */
1959     int i, j, holdingsColumn, holdingsStartRow, direction, countsColumn;
1960     char p;
1961     ChessSquare piece;
1962
1963     if(gameInfo.holdingsWidth < 2)  return;
1964     if(gameInfo.variant != VariantBughouse && board[HOLDINGS_SET])
1965         return; // prevent overwriting by pre-board holdings
1966
1967     if( (int)lowestPiece >= BlackPawn ) {
1968         holdingsColumn = 0;
1969         countsColumn = 1;
1970         holdingsStartRow = BOARD_HEIGHT-1;
1971         direction = -1;
1972     } else {
1973         holdingsColumn = BOARD_WIDTH-1;
1974         countsColumn = BOARD_WIDTH-2;
1975         holdingsStartRow = 0;
1976         direction = 1;
1977     }
1978
1979     for(i=0; i<BOARD_HEIGHT; i++) { /* clear holdings */
1980         board[i][holdingsColumn] = EmptySquare;
1981         board[i][countsColumn]   = (ChessSquare) 0;
1982     }
1983     while( (p=*holdings++) != NULLCHAR ) {
1984         piece = CharToPiece( ToUpper(p) );
1985         if(piece == EmptySquare) continue;
1986         /*j = (int) piece - (int) WhitePawn;*/
1987         j = PieceToNumber(piece);
1988         if(j >= gameInfo.holdingsSize) continue; /* ignore pieces that do not fit */
1989         if(j < 0) continue;               /* should not happen */
1990         piece = (ChessSquare) ( (int)piece + (int)lowestPiece );
1991         board[holdingsStartRow+j*direction][holdingsColumn] = piece;
1992         board[holdingsStartRow+j*direction][countsColumn]++;
1993     }
1994 }
1995
1996
1997 void
1998 VariantSwitch(Board board, VariantClass newVariant)
1999 {
2000    int newHoldingsWidth, newWidth = 8, newHeight = 8, i, j;
2001    static Board oldBoard;
2002
2003    startedFromPositionFile = FALSE;
2004    if(gameInfo.variant == newVariant) return;
2005
2006    /* [HGM] This routine is called each time an assignment is made to
2007     * gameInfo.variant during a game, to make sure the board sizes
2008     * are set to match the new variant. If that means adding or deleting
2009     * holdings, we shift the playing board accordingly
2010     * This kludge is needed because in ICS observe mode, we get boards
2011     * of an ongoing game without knowing the variant, and learn about the
2012     * latter only later. This can be because of the move list we requested,
2013     * in which case the game history is refilled from the beginning anyway,
2014     * but also when receiving holdings of a crazyhouse game. In the latter
2015     * case we want to add those holdings to the already received position.
2016     */
2017
2018
2019    if (appData.debugMode) {
2020      fprintf(debugFP, "Switch board from %s to %s\n",
2021              VariantName(gameInfo.variant), VariantName(newVariant));
2022      setbuf(debugFP, NULL);
2023    }
2024    shuffleOpenings = 0;       /* [HGM] shuffle */
2025    gameInfo.holdingsSize = 5; /* [HGM] prepare holdings */
2026    switch(newVariant)
2027      {
2028      case VariantShogi:
2029        newWidth = 9;  newHeight = 9;
2030        gameInfo.holdingsSize = 7;
2031      case VariantBughouse:
2032      case VariantCrazyhouse:
2033        newHoldingsWidth = 2; break;
2034      case VariantGreat:
2035        newWidth = 10;
2036      case VariantSuper:
2037        newHoldingsWidth = 2;
2038        gameInfo.holdingsSize = 8;
2039        break;
2040      case VariantGothic:
2041      case VariantCapablanca:
2042      case VariantCapaRandom:
2043        newWidth = 10;
2044      default:
2045        newHoldingsWidth = gameInfo.holdingsSize = 0;
2046      };
2047
2048    if(newWidth  != gameInfo.boardWidth  ||
2049       newHeight != gameInfo.boardHeight ||
2050       newHoldingsWidth != gameInfo.holdingsWidth ) {
2051
2052      /* shift position to new playing area, if needed */
2053      if(newHoldingsWidth > gameInfo.holdingsWidth) {
2054        for(i=0; i<BOARD_HEIGHT; i++)
2055          for(j=BOARD_RGHT-1; j>=BOARD_LEFT; j--)
2056            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2057              board[i][j];
2058        for(i=0; i<newHeight; i++) {
2059          board[i][0] = board[i][newWidth+2*newHoldingsWidth-1] = EmptySquare;
2060          board[i][1] = board[i][newWidth+2*newHoldingsWidth-2] = (ChessSquare) 0;
2061        }
2062      } else if(newHoldingsWidth < gameInfo.holdingsWidth) {
2063        for(i=0; i<BOARD_HEIGHT; i++)
2064          for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
2065            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2066              board[i][j];
2067      }
2068      gameInfo.boardWidth  = newWidth;
2069      gameInfo.boardHeight = newHeight;
2070      gameInfo.holdingsWidth = newHoldingsWidth;
2071      gameInfo.variant = newVariant;
2072      InitDrawingSizes(-2, 0);
2073    } else gameInfo.variant = newVariant;
2074    CopyBoard(oldBoard, board);   // remember correctly formatted board
2075      InitPosition(FALSE);          /* this sets up board[0], but also other stuff        */
2076    DrawPosition(TRUE, currentMove ? boards[currentMove] : oldBoard);
2077 }
2078
2079 static int loggedOn = FALSE;
2080
2081 /*-- Game start info cache: --*/
2082 int gs_gamenum;
2083 char gs_kind[MSG_SIZ];
2084 static char player1Name[128] = "";
2085 static char player2Name[128] = "";
2086 static char cont_seq[] = "\n\\   ";
2087 static int player1Rating = -1;
2088 static int player2Rating = -1;
2089 /*----------------------------*/
2090
2091 ColorClass curColor = ColorNormal;
2092 int suppressKibitz = 0;
2093
2094 // [HGM] seekgraph
2095 Boolean soughtPending = FALSE;
2096 Boolean seekGraphUp;
2097 #define MAX_SEEK_ADS 200
2098 #define SQUARE 0x80
2099 char *seekAdList[MAX_SEEK_ADS];
2100 int ratingList[MAX_SEEK_ADS], xList[MAX_SEEK_ADS], yList[MAX_SEEK_ADS], seekNrList[MAX_SEEK_ADS], zList[MAX_SEEK_ADS];
2101 float tcList[MAX_SEEK_ADS];
2102 char colorList[MAX_SEEK_ADS];
2103 int nrOfSeekAds = 0;
2104 int minRating = 1010, maxRating = 2800;
2105 int hMargin = 10, vMargin = 20, h, w;
2106 extern int squareSize, lineGap;
2107
2108 void
2109 PlotSeekAd(int i)
2110 {
2111         int x, y, color = 0, r = ratingList[i]; float tc = tcList[i];
2112         xList[i] = yList[i] = -100; // outside graph, so cannot be clicked
2113         if(r < minRating+100 && r >=0 ) r = minRating+100;
2114         if(r > maxRating) r = maxRating;
2115         if(tc < 1.) tc = 1.;
2116         if(tc > 95.) tc = 95.;
2117         x = (w-hMargin-squareSize/8-7)* log(tc)/log(95.) + hMargin;
2118         y = ((double)r - minRating)/(maxRating - minRating)
2119             * (h-vMargin-squareSize/8-1) + vMargin;
2120         if(ratingList[i] < 0) y = vMargin + squareSize/4;
2121         if(strstr(seekAdList[i], " u ")) color = 1;
2122         if(!strstr(seekAdList[i], "lightning") && // for now all wilds same color
2123            !strstr(seekAdList[i], "bullet") &&
2124            !strstr(seekAdList[i], "blitz") &&
2125            !strstr(seekAdList[i], "standard") ) color = 2;
2126         if(strstr(seekAdList[i], "(C) ")) color |= SQUARE; // plot computer seeks as squares
2127         DrawSeekDot(xList[i]=x+3*(color&~SQUARE), yList[i]=h-1-y, colorList[i]=color);
2128 }
2129
2130 void
2131 AddAd(char *handle, char *rating, int base, int inc,  char rated, char *type, int nr, Boolean plot)
2132 {
2133         char buf[MSG_SIZ], *ext = "";
2134         VariantClass v = StringToVariant(type);
2135         if(strstr(type, "wild")) {
2136             ext = type + 4; // append wild number
2137             if(v == VariantFischeRandom) type = "chess960"; else
2138             if(v == VariantLoadable) type = "setup"; else
2139             type = VariantName(v);
2140         }
2141         sprintf(buf, "%s (%s) %d %d %c %s%s", handle, rating, base, inc, rated, type, ext);
2142         if(nrOfSeekAds < MAX_SEEK_ADS-1) {
2143             if(seekAdList[nrOfSeekAds]) free(seekAdList[nrOfSeekAds]);
2144             ratingList[nrOfSeekAds] = -1; // for if seeker has no rating
2145             sscanf(rating, "%d", &ratingList[nrOfSeekAds]);
2146             tcList[nrOfSeekAds] = base + (2./3.)*inc;
2147             seekNrList[nrOfSeekAds] = nr;
2148             zList[nrOfSeekAds] = 0;
2149             seekAdList[nrOfSeekAds++] = StrSave(buf);
2150             if(plot) PlotSeekAd(nrOfSeekAds-1);
2151         }
2152 }
2153
2154 void
2155 EraseSeekDot(int i)
2156 {
2157     int x = xList[i], y = yList[i], d=squareSize/4, k;
2158     DrawSeekBackground(x-squareSize/8, y-squareSize/8, x+squareSize/8+1, y+squareSize/8+1);
2159     if(x < hMargin+d) DrawSeekAxis(hMargin, y-squareSize/8, hMargin, y+squareSize/8+1);
2160     // now replot every dot that overlapped
2161     for(k=0; k<nrOfSeekAds; k++) if(k != i) {
2162         int xx = xList[k], yy = yList[k];
2163         if(xx <= x+d && xx > x-d && yy <= y+d && yy > y-d)
2164             DrawSeekDot(xx, yy, colorList[k]);
2165     }
2166 }
2167
2168 void
2169 RemoveSeekAd(int nr)
2170 {
2171         int i;
2172         for(i=0; i<nrOfSeekAds; i++) if(seekNrList[i] == nr) {
2173             EraseSeekDot(i);
2174             if(seekAdList[i]) free(seekAdList[i]);
2175             seekAdList[i] = seekAdList[--nrOfSeekAds];
2176             seekNrList[i] = seekNrList[nrOfSeekAds];
2177             ratingList[i] = ratingList[nrOfSeekAds];
2178             colorList[i]  = colorList[nrOfSeekAds];
2179             tcList[i] = tcList[nrOfSeekAds];
2180             xList[i]  = xList[nrOfSeekAds];
2181             yList[i]  = yList[nrOfSeekAds];
2182             zList[i]  = zList[nrOfSeekAds];
2183             seekAdList[nrOfSeekAds] = NULL;
2184             break;
2185         }
2186 }
2187
2188 Boolean
2189 MatchSoughtLine(char *line)
2190 {
2191     char handle[MSG_SIZ], rating[MSG_SIZ], type[MSG_SIZ];
2192     int nr, base, inc, u=0; char dummy;
2193
2194     if(sscanf(line, "%d %s %s %d %d rated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
2195        sscanf(line, "%d %s %s %s %d %d rated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7 ||
2196        (u=1) &&
2197        (sscanf(line, "%d %s %s %d %d unrated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
2198         sscanf(line, "%d %s %s %s %d %d unrated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7)  ) {
2199         // match: compact and save the line
2200         AddAd(handle, rating, base, inc, u ? 'u' : 'r', type, nr, FALSE);
2201         return TRUE;
2202     }
2203     return FALSE;
2204 }
2205
2206 int
2207 DrawSeekGraph()
2208 {
2209     int i;
2210     if(!seekGraphUp) return FALSE;
2211     h = BOARD_HEIGHT * (squareSize + lineGap) + lineGap;
2212     w = BOARD_WIDTH  * (squareSize + lineGap) + lineGap;
2213
2214     DrawSeekBackground(0, 0, w, h);
2215     DrawSeekAxis(hMargin, h-1-vMargin, w-5, h-1-vMargin);
2216     DrawSeekAxis(hMargin, h-1-vMargin, hMargin, 5);
2217     for(i=0; i<4000; i+= 100) if(i>=minRating && i<maxRating) {
2218         int yy =((double)i - minRating)/(maxRating - minRating)*(h-vMargin-squareSize/8-1) + vMargin;
2219         yy = h-1-yy;
2220         DrawSeekAxis(hMargin+5*(i%500==0), yy, hMargin-5, yy); // rating ticks
2221         if(i%500 == 0) {
2222             char buf[MSG_SIZ];
2223             sprintf(buf, "%d", i);
2224             DrawSeekText(buf, hMargin+squareSize/8+7, yy);
2225         }
2226     }
2227     DrawSeekText("unrated", hMargin+squareSize/8+7, h-1-vMargin-squareSize/4);
2228     for(i=1; i<100; i+=(i<10?1:5)) {
2229         int xx = (w-hMargin-squareSize/8-7)* log((double)i)/log(95.) + hMargin;
2230         DrawSeekAxis(xx, h-1-vMargin, xx, h-6-vMargin-3*(i%10==0)); // TC ticks
2231         if(i<=5 || (i>40 ? i%20 : i%10) == 0) {
2232             char buf[MSG_SIZ];
2233             sprintf(buf, "%d", i);
2234             DrawSeekText(buf, xx-2-3*(i>9), h-1-vMargin/2);
2235         }
2236     }
2237     for(i=0; i<nrOfSeekAds; i++) PlotSeekAd(i);
2238     return TRUE;
2239 }
2240
2241 int SeekGraphClick(ClickType click, int x, int y, int moving)
2242 {
2243     static int lastDown = 0, displayed = 0, lastSecond;
2244     if(!seekGraphUp) { // initiate cration of seek graph by requesting seek-ad list
2245         if(click == Release || moving) return FALSE;
2246         nrOfSeekAds = 0;
2247         soughtPending = TRUE;
2248         SendToICS(ics_prefix);
2249         SendToICS("sought\n"); // should this be "sought all"?
2250     } else { // issue challenge based on clicked ad
2251         int dist = 10000; int i, closest = 0, second = 0;
2252         for(i=0; i<nrOfSeekAds; i++) {
2253             int d = (x-xList[i])*(x-xList[i]) +  (y-yList[i])*(y-yList[i]) + zList[i];
2254             if(d < dist) { dist = d; closest = i; }
2255             second += (d - zList[i] < 120); // count in-range ads
2256             if(click == Press && moving != 1 && zList[i]>0) zList[i] *= 0.8; // age priority
2257         }
2258         if(dist < 120) {
2259             char buf[MSG_SIZ];
2260             second = (second > 1);
2261             if(displayed != closest || second != lastSecond) {
2262                 DisplayMessage(second ? "!" : "", seekAdList[closest]);
2263                 lastSecond = second; displayed = closest;
2264             }
2265             if(click == Press) {
2266                 if(moving == 2) zList[closest] = 100; // right-click; push to back on press
2267                 lastDown = closest;
2268                 return TRUE;
2269             } // on press 'hit', only show info
2270             if(moving == 2) return TRUE; // ignore right up-clicks on dot
2271             sprintf(buf, "play %d\n", seekNrList[closest]);
2272             SendToICS(ics_prefix);
2273             SendToICS(buf);
2274             return TRUE; // let incoming board of started game pop down the graph
2275         } else if(click == Release) { // release 'miss' is ignored
2276             zList[lastDown] = 100; // make future selection of the rejected ad more difficult
2277             if(moving == 2) { // right up-click
2278                 nrOfSeekAds = 0; // refresh graph
2279                 soughtPending = TRUE;
2280                 SendToICS(ics_prefix);
2281                 SendToICS("sought\n"); // should this be "sought all"?
2282             }
2283             return TRUE;
2284         } else if(moving) { if(displayed >= 0) DisplayMessage("", ""); displayed = -1; return TRUE; }
2285         // press miss or release hit 'pop down' seek graph
2286         seekGraphUp = FALSE;
2287         DrawPosition(TRUE, NULL);
2288     }
2289     return TRUE;
2290 }
2291
2292 void
2293 read_from_ics(isr, closure, data, count, error)
2294      InputSourceRef isr;
2295      VOIDSTAR closure;
2296      char *data;
2297      int count;
2298      int error;
2299 {
2300 #define BUF_SIZE (16*1024) /* overflowed at 8K with "inchannel 1" on FICS? */
2301 #define STARTED_NONE 0
2302 #define STARTED_MOVES 1
2303 #define STARTED_BOARD 2
2304 #define STARTED_OBSERVE 3
2305 #define STARTED_HOLDINGS 4
2306 #define STARTED_CHATTER 5
2307 #define STARTED_COMMENT 6
2308 #define STARTED_MOVES_NOHIDE 7
2309
2310     static int started = STARTED_NONE;
2311     static char parse[20000];
2312     static int parse_pos = 0;
2313     static char buf[BUF_SIZE + 1];
2314     static int firstTime = TRUE, intfSet = FALSE;
2315     static ColorClass prevColor = ColorNormal;
2316     static int savingComment = FALSE;
2317     static int cmatch = 0; // continuation sequence match
2318     char *bp;
2319     char str[500];
2320     int i, oldi;
2321     int buf_len;
2322     int next_out;
2323     int tkind;
2324     int backup;    /* [DM] For zippy color lines */
2325     char *p;
2326     char talker[MSG_SIZ]; // [HGM] chat
2327     int channel;
2328
2329     connectionAlive = TRUE; // [HGM] alive: I think, therefore I am...
2330
2331     if (appData.debugMode) {
2332       if (!error) {
2333         fprintf(debugFP, "<ICS: ");
2334         show_bytes(debugFP, data, count);
2335         fprintf(debugFP, "\n");
2336       }
2337     }
2338
2339     if (appData.debugMode) { int f = forwardMostMove;
2340         fprintf(debugFP, "ics input %d, castling = %d %d %d %d %d %d\n", f,
2341                 boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
2342                 boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
2343     }
2344     if (count > 0) {
2345         /* If last read ended with a partial line that we couldn't parse,
2346            prepend it to the new read and try again. */
2347         if (leftover_len > 0) {
2348             for (i=0; i<leftover_len; i++)
2349               buf[i] = buf[leftover_start + i];
2350         }
2351
2352     /* copy new characters into the buffer */
2353     bp = buf + leftover_len;
2354     buf_len=leftover_len;
2355     for (i=0; i<count; i++)
2356     {
2357         // ignore these
2358         if (data[i] == '\r')
2359             continue;
2360
2361         // join lines split by ICS?
2362         if (!appData.noJoin)
2363         {
2364             /*
2365                 Joining just consists of finding matches against the
2366                 continuation sequence, and discarding that sequence
2367                 if found instead of copying it.  So, until a match
2368                 fails, there's nothing to do since it might be the
2369                 complete sequence, and thus, something we don't want
2370                 copied.
2371             */
2372             if (data[i] == cont_seq[cmatch])
2373             {
2374                 cmatch++;
2375                 if (cmatch == strlen(cont_seq))
2376                 {
2377                     cmatch = 0; // complete match.  just reset the counter
2378
2379                     /*
2380                         it's possible for the ICS to not include the space
2381                         at the end of the last word, making our [correct]
2382                         join operation fuse two separate words.  the server
2383                         does this when the space occurs at the width setting.
2384                     */
2385                     if (!buf_len || buf[buf_len-1] != ' ')
2386                     {
2387                         *bp++ = ' ';
2388                         buf_len++;
2389                     }
2390                 }
2391                 continue;
2392             }
2393             else if (cmatch)
2394             {
2395                 /*
2396                     match failed, so we have to copy what matched before
2397                     falling through and copying this character.  In reality,
2398                     this will only ever be just the newline character, but
2399                     it doesn't hurt to be precise.
2400                 */
2401                 strncpy(bp, cont_seq, cmatch);
2402                 bp += cmatch;
2403                 buf_len += cmatch;
2404                 cmatch = 0;
2405             }
2406         }
2407
2408         // copy this char
2409         *bp++ = data[i];
2410         buf_len++;
2411     }
2412
2413         buf[buf_len] = NULLCHAR;
2414 //      next_out = leftover_len; // [HGM] should we set this to 0, and not print it in advance?
2415         next_out = 0;
2416         leftover_start = 0;
2417
2418         i = 0;
2419         while (i < buf_len) {
2420             /* Deal with part of the TELNET option negotiation
2421                protocol.  We refuse to do anything beyond the
2422                defaults, except that we allow the WILL ECHO option,
2423                which ICS uses to turn off password echoing when we are
2424                directly connected to it.  We reject this option
2425                if localLineEditing mode is on (always on in xboard)
2426                and we are talking to port 23, which might be a real
2427                telnet server that will try to keep WILL ECHO on permanently.
2428              */
2429             if (buf_len - i >= 3 && (unsigned char) buf[i] == TN_IAC) {
2430                 static int remoteEchoOption = FALSE; /* telnet ECHO option */
2431                 unsigned char option;
2432                 oldi = i;
2433                 switch ((unsigned char) buf[++i]) {
2434                   case TN_WILL:
2435                     if (appData.debugMode)
2436                       fprintf(debugFP, "\n<WILL ");
2437                     switch (option = (unsigned char) buf[++i]) {
2438                       case TN_ECHO:
2439                         if (appData.debugMode)
2440                           fprintf(debugFP, "ECHO ");
2441                         /* Reply only if this is a change, according
2442                            to the protocol rules. */
2443                         if (remoteEchoOption) break;
2444                         if (appData.localLineEditing &&
2445                             atoi(appData.icsPort) == TN_PORT) {
2446                             TelnetRequest(TN_DONT, TN_ECHO);
2447                         } else {
2448                             EchoOff();
2449                             TelnetRequest(TN_DO, TN_ECHO);
2450                             remoteEchoOption = TRUE;
2451                         }
2452                         break;
2453                       default:
2454                         if (appData.debugMode)
2455                           fprintf(debugFP, "%d ", option);
2456                         /* Whatever this is, we don't want it. */
2457                         TelnetRequest(TN_DONT, option);
2458                         break;
2459                     }
2460                     break;
2461                   case TN_WONT:
2462                     if (appData.debugMode)
2463                       fprintf(debugFP, "\n<WONT ");
2464                     switch (option = (unsigned char) buf[++i]) {
2465                       case TN_ECHO:
2466                         if (appData.debugMode)
2467                           fprintf(debugFP, "ECHO ");
2468                         /* Reply only if this is a change, according
2469                            to the protocol rules. */
2470                         if (!remoteEchoOption) break;
2471                         EchoOn();
2472                         TelnetRequest(TN_DONT, TN_ECHO);
2473                         remoteEchoOption = FALSE;
2474                         break;
2475                       default:
2476                         if (appData.debugMode)
2477                           fprintf(debugFP, "%d ", (unsigned char) option);
2478                         /* Whatever this is, it must already be turned
2479                            off, because we never agree to turn on
2480                            anything non-default, so according to the
2481                            protocol rules, we don't reply. */
2482                         break;
2483                     }
2484                     break;
2485                   case TN_DO:
2486                     if (appData.debugMode)
2487                       fprintf(debugFP, "\n<DO ");
2488                     switch (option = (unsigned char) buf[++i]) {
2489                       default:
2490                         /* Whatever this is, we refuse to do it. */
2491                         if (appData.debugMode)
2492                           fprintf(debugFP, "%d ", option);
2493                         TelnetRequest(TN_WONT, option);
2494                         break;
2495                     }
2496                     break;
2497                   case TN_DONT:
2498                     if (appData.debugMode)
2499                       fprintf(debugFP, "\n<DONT ");
2500                     switch (option = (unsigned char) buf[++i]) {
2501                       default:
2502                         if (appData.debugMode)
2503                           fprintf(debugFP, "%d ", option);
2504                         /* Whatever this is, we are already not doing
2505                            it, because we never agree to do anything
2506                            non-default, so according to the protocol
2507                            rules, we don't reply. */
2508                         break;
2509                     }
2510                     break;
2511                   case TN_IAC:
2512                     if (appData.debugMode)
2513                       fprintf(debugFP, "\n<IAC ");
2514                     /* Doubled IAC; pass it through */
2515                     i--;
2516                     break;
2517                   default:
2518                     if (appData.debugMode)
2519                       fprintf(debugFP, "\n<%d ", (unsigned char) buf[i]);
2520                     /* Drop all other telnet commands on the floor */
2521                     break;
2522                 }
2523                 if (oldi > next_out)
2524                   SendToPlayer(&buf[next_out], oldi - next_out);
2525                 if (++i > next_out)
2526                   next_out = i;
2527                 continue;
2528             }
2529
2530             /* OK, this at least will *usually* work */
2531             if (!loggedOn && looking_at(buf, &i, "ics%")) {
2532                 loggedOn = TRUE;
2533             }
2534
2535             if (loggedOn && !intfSet) {
2536                 if (ics_type == ICS_ICC) {
2537                   sprintf(str,
2538                           "/set-quietly interface %s\n/set-quietly style 12\n",
2539                           programVersion);
2540                   if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
2541                       strcat(str, "/set-2 51 1\n/set seek 1\n");
2542                 } else if (ics_type == ICS_CHESSNET) {
2543                   sprintf(str, "/style 12\n");
2544                 } else {
2545                   strcpy(str, "alias $ @\n$set interface ");
2546                   strcat(str, programVersion);
2547                   strcat(str, "\n$iset startpos 1\n$iset ms 1\n");
2548                   if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
2549                       strcat(str, "$iset seekremove 1\n$set seek 1\n");
2550 #ifdef WIN32
2551                   strcat(str, "$iset nohighlight 1\n");
2552 #endif
2553                   strcat(str, "$iset lock 1\n$style 12\n");
2554                 }
2555                 SendToICS(str);
2556                 NotifyFrontendLogin();
2557                 intfSet = TRUE;
2558             }
2559
2560             if (started == STARTED_COMMENT) {
2561                 /* Accumulate characters in comment */
2562                 parse[parse_pos++] = buf[i];
2563                 if (buf[i] == '\n') {
2564                     parse[parse_pos] = NULLCHAR;
2565                     if(chattingPartner>=0) {
2566                         char mess[MSG_SIZ];
2567                         sprintf(mess, "%s%s", talker, parse);
2568                         OutputChatMessage(chattingPartner, mess);
2569                         chattingPartner = -1;
2570                         next_out = i+1; // [HGM] suppress printing in ICS window
2571                     } else
2572                     if(!suppressKibitz) // [HGM] kibitz
2573                         AppendComment(forwardMostMove, StripHighlight(parse), TRUE);
2574                     else { // [HGM kibitz: divert memorized engine kibitz to engine-output window
2575                         int nrDigit = 0, nrAlph = 0, j;
2576                         if(parse_pos > MSG_SIZ - 30) // defuse unreasonably long input
2577                         { parse_pos = MSG_SIZ-30; parse[parse_pos - 1] = '\n'; }
2578                         parse[parse_pos] = NULLCHAR;
2579                         // try to be smart: if it does not look like search info, it should go to
2580                         // ICS interaction window after all, not to engine-output window.
2581                         for(j=0; j<parse_pos; j++) { // count letters and digits
2582                             nrDigit += (parse[j] >= '0' && parse[j] <= '9');
2583                             nrAlph  += (parse[j] >= 'a' && parse[j] <= 'z');
2584                             nrAlph  += (parse[j] >= 'A' && parse[j] <= 'Z');
2585                         }
2586                         if(nrAlph < 9*nrDigit) { // if more than 10% digit we assume search info
2587                             int depth=0; float score;
2588                             if(sscanf(parse, "!!! %f/%d", &score, &depth) == 2 && depth>0) {
2589                                 // [HGM] kibitz: save kibitzed opponent info for PGN and eval graph
2590                                 pvInfoList[forwardMostMove-1].depth = depth;
2591                                 pvInfoList[forwardMostMove-1].score = 100*score;
2592                             }
2593                             OutputKibitz(suppressKibitz, parse);
2594                         } else {
2595                             char tmp[MSG_SIZ];
2596                             sprintf(tmp, _("your opponent kibitzes: %s"), parse);
2597                             SendToPlayer(tmp, strlen(tmp));
2598                         }
2599                         next_out = i+1; // [HGM] suppress printing in ICS window
2600                     }
2601                     started = STARTED_NONE;
2602                 } else {
2603                     /* Don't match patterns against characters in comment */
2604                     i++;
2605                     continue;
2606                 }
2607             }
2608             if (started == STARTED_CHATTER) {
2609                 if (buf[i] != '\n') {
2610                     /* Don't match patterns against characters in chatter */
2611                     i++;
2612                     continue;
2613                 }
2614                 started = STARTED_NONE;
2615                 if(suppressKibitz) next_out = i+1;
2616             }
2617
2618             /* Kludge to deal with rcmd protocol */
2619             if (firstTime && looking_at(buf, &i, "\001*")) {
2620                 DisplayFatalError(&buf[1], 0, 1);
2621                 continue;
2622             } else {
2623                 firstTime = FALSE;
2624             }
2625
2626             if (!loggedOn && looking_at(buf, &i, "chessclub.com")) {
2627                 ics_type = ICS_ICC;
2628                 ics_prefix = "/";
2629                 if (appData.debugMode)
2630                   fprintf(debugFP, "ics_type %d\n", ics_type);
2631                 continue;
2632             }
2633             if (!loggedOn && looking_at(buf, &i, "freechess.org")) {
2634                 ics_type = ICS_FICS;
2635                 ics_prefix = "$";
2636                 if (appData.debugMode)
2637                   fprintf(debugFP, "ics_type %d\n", ics_type);
2638                 continue;
2639             }
2640             if (!loggedOn && looking_at(buf, &i, "chess.net")) {
2641                 ics_type = ICS_CHESSNET;
2642                 ics_prefix = "/";
2643                 if (appData.debugMode)
2644                   fprintf(debugFP, "ics_type %d\n", ics_type);
2645                 continue;
2646             }
2647
2648             if (!loggedOn &&
2649                 (looking_at(buf, &i, "\"*\" is *a registered name") ||
2650                  looking_at(buf, &i, "Logging you in as \"*\"") ||
2651                  looking_at(buf, &i, "will be \"*\""))) {
2652               strcpy(ics_handle, star_match[0]);
2653               continue;
2654             }
2655
2656             if (loggedOn && !have_set_title && ics_handle[0] != NULLCHAR) {
2657               char buf[MSG_SIZ];
2658               snprintf(buf, sizeof(buf), "%s@%s", ics_handle, appData.icsHost);
2659               DisplayIcsInteractionTitle(buf);
2660               have_set_title = TRUE;
2661             }
2662
2663             /* skip finger notes */
2664             if (started == STARTED_NONE &&
2665                 ((buf[i] == ' ' && isdigit(buf[i+1])) ||
2666                  (buf[i] == '1' && buf[i+1] == '0')) &&
2667                 buf[i+2] == ':' && buf[i+3] == ' ') {
2668               started = STARTED_CHATTER;
2669               i += 3;
2670               continue;
2671             }
2672
2673             oldi = i;
2674             // [HGM] seekgraph: recognize sought lines and end-of-sought message
2675             if(appData.seekGraph) {
2676                 if(soughtPending && MatchSoughtLine(buf+i)) {
2677                     i = strstr(buf+i, "rated") - buf;
2678                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2679                     next_out = leftover_start = i;
2680                     started = STARTED_CHATTER;
2681                     suppressKibitz = TRUE;
2682                     continue;
2683                 }
2684                 if((gameMode == IcsIdle || gameMode == BeginningOfGame)
2685                         && looking_at(buf, &i, "* ads displayed")) {
2686                     soughtPending = FALSE;
2687                     seekGraphUp = TRUE;
2688                     DrawSeekGraph();
2689                     continue;
2690                 }
2691                 if(appData.autoRefresh) {
2692                     if(looking_at(buf, &i, "* (*) seeking * * * * *\"play *\" to respond)\n")) {
2693                         int s = (ics_type == ICS_ICC); // ICC format differs
2694                         if(seekGraphUp)
2695                         AddAd(star_match[0], star_match[1], atoi(star_match[2+s]), atoi(star_match[3+s]),
2696                               star_match[4+s][0], star_match[5-3*s], atoi(star_match[7]), TRUE);
2697                         looking_at(buf, &i, "*% "); // eat prompt
2698                         if(oldi > 0 && buf[oldi-1] == '\n') oldi--; // suppress preceding LF, if any
2699                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2700                         next_out = i; // suppress
2701                         continue;
2702                     }
2703                     if(looking_at(buf, &i, "\nAds removed: *\n") || looking_at(buf, &i, "\031(51 * *\031)")) {
2704                         char *p = star_match[0];
2705                         while(*p) {
2706                             if(seekGraphUp) RemoveSeekAd(atoi(p));
2707                             while(*p && *p++ != ' '); // next
2708                         }
2709                         looking_at(buf, &i, "*% "); // eat prompt
2710                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2711                         next_out = i;
2712                         continue;
2713                     }
2714                 }
2715             }
2716
2717             /* skip formula vars */
2718             if (started == STARTED_NONE &&
2719                 buf[i] == 'f' && isdigit(buf[i+1]) && buf[i+2] == ':') {
2720               started = STARTED_CHATTER;
2721               i += 3;
2722               continue;
2723             }
2724
2725             // [HGM] kibitz: try to recognize opponent engine-score kibitzes, to divert them to engine-output window
2726             if (appData.autoKibitz && started == STARTED_NONE &&
2727                 !appData.icsEngineAnalyze &&                     // [HGM] [DM] ICS analyze
2728                 (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack || gameMode == IcsObserving)) {
2729                 if((looking_at(buf, &i, "* kibitzes: ") || looking_at(buf, &i, "* whispers: ")) &&
2730                    (StrStr(star_match[0], gameInfo.white) == star_match[0] ||
2731                     StrStr(star_match[0], gameInfo.black) == star_match[0]   )) { // kibitz of self or opponent
2732                         suppressKibitz = TRUE;
2733                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2734                         next_out = i;
2735                         if((StrStr(star_match[0], gameInfo.white) == star_match[0]
2736                                 && (gameMode == IcsPlayingWhite)) ||
2737                            (StrStr(star_match[0], gameInfo.black) == star_match[0]
2738                                 && (gameMode == IcsPlayingBlack))   ) // opponent kibitz
2739                             started = STARTED_CHATTER; // own kibitz we simply discard
2740                         else {
2741                             started = STARTED_COMMENT; // make sure it will be collected in parse[]
2742                             parse_pos = 0; parse[0] = NULLCHAR;
2743                             savingComment = TRUE;
2744                             suppressKibitz = gameMode != IcsObserving ? 2 :
2745                                 (StrStr(star_match[0], gameInfo.white) == NULL) + 1;
2746                         }
2747                         continue;
2748                 } else
2749                 if((looking_at(buf, &i, "\nkibitzed to *\n") || looking_at(buf, &i, "kibitzed to *\n") ||
2750                     looking_at(buf, &i, "\n(kibitzed to *\n") || looking_at(buf, &i, "(kibitzed to *\n"))
2751                          && atoi(star_match[0])) {
2752                     // suppress the acknowledgements of our own autoKibitz
2753                     char *p;
2754                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2755                     if(p = strchr(star_match[0], ' ')) p[1] = NULLCHAR; // clip off "players)" on FICS
2756                     SendToPlayer(star_match[0], strlen(star_match[0]));
2757                     if(looking_at(buf, &i, "*% ")) // eat prompt
2758                         suppressKibitz = FALSE;
2759                     next_out = i;
2760                     continue;
2761                 }
2762             } // [HGM] kibitz: end of patch
2763
2764             // [HGM] chat: intercept tells by users for which we have an open chat window
2765             channel = -1;
2766             if(started == STARTED_NONE && (looking_at(buf, &i, "* tells you:") || looking_at(buf, &i, "* says:") ||
2767                                            looking_at(buf, &i, "* whispers:") ||
2768                                            looking_at(buf, &i, "* kibitzes:") ||
2769                                            looking_at(buf, &i, "* shouts:") ||
2770                                            looking_at(buf, &i, "* c-shouts:") ||
2771                                            looking_at(buf, &i, "--> * ") ||
2772                                            looking_at(buf, &i, "*(*):") && (sscanf(star_match[1], "%d", &channel),1) ||
2773                                            looking_at(buf, &i, "*(*)(*):") && (sscanf(star_match[2], "%d", &channel),1) ||
2774                                            looking_at(buf, &i, "*(*)(*)(*):") && (sscanf(star_match[3], "%d", &channel),1) ||
2775                                            looking_at(buf, &i, "*(*)(*)(*)(*):") && sscanf(star_match[4], "%d", &channel) == 1 )) {
2776                 int p;
2777                 sscanf(star_match[0], "%[^(]", talker+1); // strip (C) or (U) off ICS handle
2778                 chattingPartner = -1;
2779
2780                 if(channel >= 0) // channel broadcast; look if there is a chatbox for this channel
2781                 for(p=0; p<MAX_CHAT; p++) {
2782                     if(channel == atoi(chatPartner[p])) {
2783                     talker[0] = '['; strcat(talker, "] ");
2784                     Colorize(channel == 1 ? ColorChannel1 : ColorChannel, FALSE);
2785                     chattingPartner = p; break;
2786                     }
2787                 } else
2788                 if(buf[i-3] == 'e') // kibitz; look if there is a KIBITZ chatbox
2789                 for(p=0; p<MAX_CHAT; p++) {
2790                     if(!strcmp("kibitzes", chatPartner[p])) {
2791                         talker[0] = '['; strcat(talker, "] ");
2792                         chattingPartner = p; break;
2793                     }
2794                 } else
2795                 if(buf[i-3] == 'r') // whisper; look if there is a WHISPER chatbox
2796                 for(p=0; p<MAX_CHAT; p++) {
2797                     if(!strcmp("whispers", chatPartner[p])) {
2798                         talker[0] = '['; strcat(talker, "] ");
2799                         chattingPartner = p; break;
2800                     }
2801                 } else
2802                 if(buf[i-3] == 't' || buf[oldi+2] == '>') {// shout, c-shout or it; look if there is a 'shouts' chatbox
2803                   if(buf[i-8] == '-' && buf[i-3] == 't')
2804                   for(p=0; p<MAX_CHAT; p++) { // c-shout; check if dedicatesd c-shout box exists
2805                     if(!strcmp("c-shouts", chatPartner[p])) {
2806                         talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE);
2807                         chattingPartner = p; break;
2808                     }
2809                   }
2810                   if(chattingPartner < 0)
2811                   for(p=0; p<MAX_CHAT; p++) {
2812                     if(!strcmp("shouts", chatPartner[p])) {
2813                         if(buf[oldi+2] == '>') { talker[0] = '<'; strcat(talker, "> "); Colorize(ColorShout, FALSE); }
2814                         else if(buf[i-8] == '-') { talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE); }
2815                         else { talker[0] = '['; strcat(talker, "] "); Colorize(ColorShout, FALSE); }
2816                         chattingPartner = p; break;
2817                     }
2818                   }
2819                 }
2820                 if(chattingPartner<0) // if not, look if there is a chatbox for this indivdual
2821                 for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
2822                     talker[0] = 0; Colorize(ColorTell, FALSE);
2823                     chattingPartner = p; break;
2824                 }
2825                 if(chattingPartner<0) i = oldi; else {
2826                     Colorize(curColor, TRUE); // undo the bogus colorations we just made to trigger the souds
2827                     if(oldi > 0 && buf[oldi-1] == '\n') oldi--;
2828                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2829                     started = STARTED_COMMENT;
2830                     parse_pos = 0; parse[0] = NULLCHAR;
2831                     savingComment = 3 + chattingPartner; // counts as TRUE
2832                     suppressKibitz = TRUE;
2833                     continue;
2834                 }
2835             } // [HGM] chat: end of patch
2836
2837             if (appData.zippyTalk || appData.zippyPlay) {
2838                 /* [DM] Backup address for color zippy lines */
2839                 backup = i;
2840 #if ZIPPY
2841                if (loggedOn == TRUE)
2842                        if (ZippyControl(buf, &backup) || ZippyConverse(buf, &backup) ||
2843                           (appData.zippyPlay && ZippyMatch(buf, &backup)));
2844 #endif
2845             } // [DM] 'else { ' deleted
2846                 if (
2847                     /* Regular tells and says */
2848                     (tkind = 1, looking_at(buf, &i, "* tells you: ")) ||
2849                     looking_at(buf, &i, "* (your partner) tells you: ") ||
2850                     looking_at(buf, &i, "* says: ") ||
2851                     /* Don't color "message" or "messages" output */
2852                     (tkind = 5, looking_at(buf, &i, "*. * (*:*): ")) ||
2853                     looking_at(buf, &i, "*. * at *:*: ") ||
2854                     looking_at(buf, &i, "--* (*:*): ") ||
2855                     /* Message notifications (same color as tells) */
2856                     looking_at(buf, &i, "* has left a message ") ||
2857                     looking_at(buf, &i, "* just sent you a message:\n") ||
2858                     /* Whispers and kibitzes */
2859                     (tkind = 2, looking_at(buf, &i, "* whispers: ")) ||
2860                     looking_at(buf, &i, "* kibitzes: ") ||
2861                     /* Channel tells */
2862                     (tkind = 3, looking_at(buf, &i, "*(*: "))) {
2863
2864                   if (tkind == 1 && strchr(star_match[0], ':')) {
2865                       /* Avoid "tells you:" spoofs in channels */
2866                      tkind = 3;
2867                   }
2868                   if (star_match[0][0] == NULLCHAR ||
2869                       strchr(star_match[0], ' ') ||
2870                       (tkind == 3 && strchr(star_match[1], ' '))) {
2871                     /* Reject bogus matches */
2872                     i = oldi;
2873                   } else {
2874                     if (appData.colorize) {
2875                       if (oldi > next_out) {
2876                         SendToPlayer(&buf[next_out], oldi - next_out);
2877                         next_out = oldi;
2878                       }
2879                       switch (tkind) {
2880                       case 1:
2881                         Colorize(ColorTell, FALSE);
2882                         curColor = ColorTell;
2883                         break;
2884                       case 2:
2885                         Colorize(ColorKibitz, FALSE);
2886                         curColor = ColorKibitz;
2887                         break;
2888                       case 3:
2889                         p = strrchr(star_match[1], '(');
2890                         if (p == NULL) {
2891                           p = star_match[1];
2892                         } else {
2893                           p++;
2894                         }
2895                         if (atoi(p) == 1) {
2896                           Colorize(ColorChannel1, FALSE);
2897                           curColor = ColorChannel1;
2898                         } else {
2899                           Colorize(ColorChannel, FALSE);
2900                           curColor = ColorChannel;
2901                         }
2902                         break;
2903                       case 5:
2904                         curColor = ColorNormal;
2905                         break;
2906                       }
2907                     }
2908                     if (started == STARTED_NONE && appData.autoComment &&
2909                         (gameMode == IcsObserving ||
2910                          gameMode == IcsPlayingWhite ||
2911                          gameMode == IcsPlayingBlack)) {
2912                       parse_pos = i - oldi;
2913                       memcpy(parse, &buf[oldi], parse_pos);
2914                       parse[parse_pos] = NULLCHAR;
2915                       started = STARTED_COMMENT;
2916                       savingComment = TRUE;
2917                     } else {
2918                       started = STARTED_CHATTER;
2919                       savingComment = FALSE;
2920                     }
2921                     loggedOn = TRUE;
2922                     continue;
2923                   }
2924                 }
2925
2926                 if (looking_at(buf, &i, "* s-shouts: ") ||
2927                     looking_at(buf, &i, "* c-shouts: ")) {
2928                     if (appData.colorize) {
2929                         if (oldi > next_out) {
2930                             SendToPlayer(&buf[next_out], oldi - next_out);
2931                             next_out = oldi;
2932                         }
2933                         Colorize(ColorSShout, FALSE);
2934                         curColor = ColorSShout;
2935                     }
2936                     loggedOn = TRUE;
2937                     started = STARTED_CHATTER;
2938                     continue;
2939                 }
2940
2941                 if (looking_at(buf, &i, "--->")) {
2942                     loggedOn = TRUE;
2943                     continue;
2944                 }
2945
2946                 if (looking_at(buf, &i, "* shouts: ") ||
2947                     looking_at(buf, &i, "--> ")) {
2948                     if (appData.colorize) {
2949                         if (oldi > next_out) {
2950                             SendToPlayer(&buf[next_out], oldi - next_out);
2951                             next_out = oldi;
2952                         }
2953                         Colorize(ColorShout, FALSE);
2954                         curColor = ColorShout;
2955                     }
2956                     loggedOn = TRUE;
2957                     started = STARTED_CHATTER;
2958                     continue;
2959                 }
2960
2961                 if (looking_at( buf, &i, "Challenge:")) {
2962                     if (appData.colorize) {
2963                         if (oldi > next_out) {
2964                             SendToPlayer(&buf[next_out], oldi - next_out);
2965                             next_out = oldi;
2966                         }
2967                         Colorize(ColorChallenge, FALSE);
2968                         curColor = ColorChallenge;
2969                     }
2970                     loggedOn = TRUE;
2971                     continue;
2972                 }
2973
2974                 if (looking_at(buf, &i, "* offers you") ||
2975                     looking_at(buf, &i, "* offers to be") ||
2976                     looking_at(buf, &i, "* would like to") ||
2977                     looking_at(buf, &i, "* requests to") ||
2978                     looking_at(buf, &i, "Your opponent offers") ||
2979                     looking_at(buf, &i, "Your opponent requests")) {
2980
2981                     if (appData.colorize) {
2982                         if (oldi > next_out) {
2983                             SendToPlayer(&buf[next_out], oldi - next_out);
2984                             next_out = oldi;
2985                         }
2986                         Colorize(ColorRequest, FALSE);
2987                         curColor = ColorRequest;
2988                     }
2989                     continue;
2990                 }
2991
2992                 if (looking_at(buf, &i, "* (*) seeking")) {
2993                     if (appData.colorize) {
2994                         if (oldi > next_out) {
2995                             SendToPlayer(&buf[next_out], oldi - next_out);
2996                             next_out = oldi;
2997                         }
2998                         Colorize(ColorSeek, FALSE);
2999                         curColor = ColorSeek;
3000                     }
3001                     continue;
3002             }
3003
3004             if (looking_at(buf, &i, "\\   ")) {
3005                 if (prevColor != ColorNormal) {
3006                     if (oldi > next_out) {
3007                         SendToPlayer(&buf[next_out], oldi - next_out);
3008                         next_out = oldi;
3009                     }
3010                     Colorize(prevColor, TRUE);
3011                     curColor = prevColor;
3012                 }
3013                 if (savingComment) {
3014                     parse_pos = i - oldi;
3015                     memcpy(parse, &buf[oldi], parse_pos);
3016                     parse[parse_pos] = NULLCHAR;
3017                     started = STARTED_COMMENT;
3018                     if(savingComment >= 3) // [HGM] chat: continuation of line for chat box
3019                         chattingPartner = savingComment - 3; // kludge to remember the box
3020                 } else {
3021                     started = STARTED_CHATTER;
3022                 }
3023                 continue;
3024             }
3025
3026             if (looking_at(buf, &i, "Black Strength :") ||
3027                 looking_at(buf, &i, "<<< style 10 board >>>") ||
3028                 looking_at(buf, &i, "<10>") ||
3029                 looking_at(buf, &i, "#@#")) {
3030                 /* Wrong board style */
3031                 loggedOn = TRUE;
3032                 SendToICS(ics_prefix);
3033                 SendToICS("set style 12\n");
3034                 SendToICS(ics_prefix);
3035                 SendToICS("refresh\n");
3036                 continue;
3037             }
3038
3039             if (!have_sent_ICS_logon && looking_at(buf, &i, "login:")) {
3040                 ICSInitScript();
3041                 have_sent_ICS_logon = 1;
3042                 continue;
3043             }
3044
3045             if (ics_getting_history != H_GETTING_MOVES /*smpos kludge*/ &&
3046                 (looking_at(buf, &i, "\n<12> ") ||
3047                  looking_at(buf, &i, "<12> "))) {
3048                 loggedOn = TRUE;
3049                 if (oldi > next_out) {
3050                     SendToPlayer(&buf[next_out], oldi - next_out);
3051                 }
3052                 next_out = i;
3053                 started = STARTED_BOARD;
3054                 parse_pos = 0;
3055                 continue;
3056             }
3057
3058             if ((started == STARTED_NONE && looking_at(buf, &i, "\n<b1> ")) ||
3059                 looking_at(buf, &i, "<b1> ")) {
3060                 if (oldi > next_out) {
3061                     SendToPlayer(&buf[next_out], oldi - next_out);
3062                 }
3063                 next_out = i;
3064                 started = STARTED_HOLDINGS;
3065                 parse_pos = 0;
3066                 continue;
3067             }
3068
3069             if (looking_at(buf, &i, "* *vs. * *--- *")) {
3070                 loggedOn = TRUE;
3071                 /* Header for a move list -- first line */
3072
3073                 switch (ics_getting_history) {
3074                   case H_FALSE:
3075                     switch (gameMode) {
3076                       case IcsIdle:
3077                       case BeginningOfGame:
3078                         /* User typed "moves" or "oldmoves" while we
3079                            were idle.  Pretend we asked for these
3080                            moves and soak them up so user can step
3081                            through them and/or save them.
3082                            */
3083                         Reset(FALSE, TRUE);
3084                         gameMode = IcsObserving;
3085                         ModeHighlight();
3086                         ics_gamenum = -1;
3087                         ics_getting_history = H_GOT_UNREQ_HEADER;
3088                         break;
3089                       case EditGame: /*?*/
3090                       case EditPosition: /*?*/
3091                         /* Should above feature work in these modes too? */
3092                         /* For now it doesn't */
3093                         ics_getting_history = H_GOT_UNWANTED_HEADER;
3094                         break;
3095                       default:
3096                         ics_getting_history = H_GOT_UNWANTED_HEADER;
3097                         break;
3098                     }
3099                     break;
3100                   case H_REQUESTED:
3101                     /* Is this the right one? */
3102                     if (gameInfo.white && gameInfo.black &&
3103                         strcmp(gameInfo.white, star_match[0]) == 0 &&
3104                         strcmp(gameInfo.black, star_match[2]) == 0) {
3105                         /* All is well */
3106                         ics_getting_history = H_GOT_REQ_HEADER;
3107                     }
3108                     break;
3109                   case H_GOT_REQ_HEADER:
3110                   case H_GOT_UNREQ_HEADER:
3111                   case H_GOT_UNWANTED_HEADER:
3112                   case H_GETTING_MOVES:
3113                     /* Should not happen */
3114                     DisplayError(_("Error gathering move list: two headers"), 0);
3115                     ics_getting_history = H_FALSE;
3116                     break;
3117                 }
3118
3119                 /* Save player ratings into gameInfo if needed */
3120                 if ((ics_getting_history == H_GOT_REQ_HEADER ||
3121                      ics_getting_history == H_GOT_UNREQ_HEADER) &&
3122                     (gameInfo.whiteRating == -1 ||
3123                      gameInfo.blackRating == -1)) {
3124
3125                     gameInfo.whiteRating = string_to_rating(star_match[1]);
3126                     gameInfo.blackRating = string_to_rating(star_match[3]);
3127                     if (appData.debugMode)
3128                       fprintf(debugFP, _("Ratings from header: W %d, B %d\n"),
3129                               gameInfo.whiteRating, gameInfo.blackRating);
3130                 }
3131                 continue;
3132             }
3133
3134             if (looking_at(buf, &i,
3135               "* * match, initial time: * minute*, increment: * second")) {
3136                 /* Header for a move list -- second line */
3137                 /* Initial board will follow if this is a wild game */
3138                 if (gameInfo.event != NULL) free(gameInfo.event);
3139                 sprintf(str, "ICS %s %s match", star_match[0], star_match[1]);
3140                 gameInfo.event = StrSave(str);
3141                 /* [HGM] we switched variant. Translate boards if needed. */
3142                 VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event));
3143                 continue;
3144             }
3145
3146             if (looking_at(buf, &i, "Move  ")) {
3147                 /* Beginning of a move list */
3148                 switch (ics_getting_history) {
3149                   case H_FALSE:
3150                     /* Normally should not happen */
3151                     /* Maybe user hit reset while we were parsing */
3152                     break;
3153                   case H_REQUESTED:
3154                     /* Happens if we are ignoring a move list that is not
3155                      * the one we just requested.  Common if the user
3156                      * tries to observe two games without turning off
3157                      * getMoveList */
3158                     break;
3159                   case H_GETTING_MOVES:
3160                     /* Should not happen */
3161                     DisplayError(_("Error gathering move list: nested"), 0);
3162                     ics_getting_history = H_FALSE;
3163                     break;
3164                   case H_GOT_REQ_HEADER:
3165                     ics_getting_history = H_GETTING_MOVES;
3166                     started = STARTED_MOVES;
3167                     parse_pos = 0;
3168                     if (oldi > next_out) {
3169                         SendToPlayer(&buf[next_out], oldi - next_out);
3170                     }
3171                     break;
3172                   case H_GOT_UNREQ_HEADER:
3173                     ics_getting_history = H_GETTING_MOVES;
3174                     started = STARTED_MOVES_NOHIDE;
3175                     parse_pos = 0;
3176                     break;
3177                   case H_GOT_UNWANTED_HEADER:
3178                     ics_getting_history = H_FALSE;
3179                     break;
3180                 }
3181                 continue;
3182             }
3183
3184             if (looking_at(buf, &i, "% ") ||
3185                 ((started == STARTED_MOVES || started == STARTED_MOVES_NOHIDE)
3186                  && looking_at(buf, &i, "}*"))) { char *bookHit = NULL; // [HGM] book
3187                 if(ics_type == ICS_ICC && soughtPending) { // [HGM] seekgraph: on ICC sought-list has no termination line
3188                     soughtPending = FALSE;
3189                     seekGraphUp = TRUE;
3190                     DrawSeekGraph();
3191                 }
3192                 if(suppressKibitz) next_out = i;
3193                 savingComment = FALSE;
3194                 suppressKibitz = 0;
3195                 switch (started) {
3196                   case STARTED_MOVES:
3197                   case STARTED_MOVES_NOHIDE:
3198                     memcpy(&parse[parse_pos], &buf[oldi], i - oldi);
3199                     parse[parse_pos + i - oldi] = NULLCHAR;
3200                     ParseGameHistory(parse);
3201 #if ZIPPY
3202                     if (appData.zippyPlay && first.initDone) {
3203                         FeedMovesToProgram(&first, forwardMostMove);
3204                         if (gameMode == IcsPlayingWhite) {
3205                             if (WhiteOnMove(forwardMostMove)) {
3206                                 if (first.sendTime) {
3207                                   if (first.useColors) {
3208                                     SendToProgram("black\n", &first);
3209                                   }
3210                                   SendTimeRemaining(&first, TRUE);
3211                                 }
3212                                 if (first.useColors) {
3213                                   SendToProgram("white\n", &first); // [HGM] book: made sending of "go\n" book dependent
3214                                 }
3215                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: probe book for initial pos
3216                                 first.maybeThinking = TRUE;
3217                             } else {
3218                                 if (first.usePlayother) {
3219                                   if (first.sendTime) {
3220                                     SendTimeRemaining(&first, TRUE);
3221                                   }
3222                                   SendToProgram("playother\n", &first);
3223                                   firstMove = FALSE;
3224                                 } else {
3225                                   firstMove = TRUE;
3226                                 }
3227                             }
3228                         } else if (gameMode == IcsPlayingBlack) {
3229                             if (!WhiteOnMove(forwardMostMove)) {
3230                                 if (first.sendTime) {
3231                                   if (first.useColors) {
3232                                     SendToProgram("white\n", &first);
3233                                   }
3234                                   SendTimeRemaining(&first, FALSE);
3235                                 }
3236                                 if (first.useColors) {
3237                                   SendToProgram("black\n", &first);
3238                                 }
3239                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE);
3240                                 first.maybeThinking = TRUE;
3241                             } else {
3242                                 if (first.usePlayother) {
3243                                   if (first.sendTime) {
3244                                     SendTimeRemaining(&first, FALSE);
3245                                   }
3246                                   SendToProgram("playother\n", &first);
3247                                   firstMove = FALSE;
3248                                 } else {
3249                                   firstMove = TRUE;
3250                                 }
3251                             }
3252                         }
3253                     }
3254 #endif
3255                     if (gameMode == IcsObserving && ics_gamenum == -1) {
3256                         /* Moves came from oldmoves or moves command
3257                            while we weren't doing anything else.
3258                            */
3259                         currentMove = forwardMostMove;
3260                         ClearHighlights();/*!!could figure this out*/
3261                         flipView = appData.flipView;
3262                         DrawPosition(TRUE, boards[currentMove]);
3263                         DisplayBothClocks();
3264                         sprintf(str, "%s vs. %s",
3265                                 gameInfo.white, gameInfo.black);
3266                         DisplayTitle(str);
3267                         gameMode = IcsIdle;
3268                     } else {
3269                         /* Moves were history of an active game */
3270                         if (gameInfo.resultDetails != NULL) {
3271                             free(gameInfo.resultDetails);
3272                             gameInfo.resultDetails = NULL;
3273                         }
3274                     }
3275                     HistorySet(parseList, backwardMostMove,
3276                                forwardMostMove, currentMove-1);
3277                     DisplayMove(currentMove - 1);
3278                     if (started == STARTED_MOVES) next_out = i;
3279                     started = STARTED_NONE;
3280                     ics_getting_history = H_FALSE;
3281                     break;
3282
3283                   case STARTED_OBSERVE:
3284                     started = STARTED_NONE;
3285                     SendToICS(ics_prefix);
3286                     SendToICS("refresh\n");
3287                     break;
3288
3289                   default:
3290                     break;
3291                 }
3292                 if(bookHit) { // [HGM] book: simulate book reply
3293                     static char bookMove[MSG_SIZ]; // a bit generous?
3294
3295                     programStats.nodes = programStats.depth = programStats.time =
3296                     programStats.score = programStats.got_only_move = 0;
3297                     sprintf(programStats.movelist, "%s (xbook)", bookHit);
3298
3299                     strcpy(bookMove, "move ");
3300                     strcat(bookMove, bookHit);
3301                     HandleMachineMove(bookMove, &first);
3302                 }
3303                 continue;
3304             }
3305
3306             if ((started == STARTED_MOVES || started == STARTED_BOARD ||
3307                  started == STARTED_HOLDINGS ||
3308                  started == STARTED_MOVES_NOHIDE) && i >= leftover_len) {
3309                 /* Accumulate characters in move list or board */
3310                 parse[parse_pos++] = buf[i];
3311             }
3312
3313             /* Start of game messages.  Mostly we detect start of game
3314                when the first board image arrives.  On some versions
3315                of the ICS, though, we need to do a "refresh" after starting
3316                to observe in order to get the current board right away. */
3317             if (looking_at(buf, &i, "Adding game * to observation list")) {
3318                 started = STARTED_OBSERVE;
3319                 continue;
3320             }
3321
3322             /* Handle auto-observe */
3323             if (appData.autoObserve &&
3324                 (gameMode == IcsIdle || gameMode == BeginningOfGame) &&
3325                 looking_at(buf, &i, "Game notification: * (*) vs. * (*)")) {
3326                 char *player;
3327                 /* Choose the player that was highlighted, if any. */
3328                 if (star_match[0][0] == '\033' ||
3329                     star_match[1][0] != '\033') {
3330                     player = star_match[0];
3331                 } else {
3332                     player = star_match[2];
3333                 }
3334                 sprintf(str, "%sobserve %s\n",
3335                         ics_prefix, StripHighlightAndTitle(player));
3336                 SendToICS(str);
3337
3338                 /* Save ratings from notify string */
3339                 strcpy(player1Name, star_match[0]);
3340                 player1Rating = string_to_rating(star_match[1]);
3341                 strcpy(player2Name, star_match[2]);
3342                 player2Rating = string_to_rating(star_match[3]);
3343
3344                 if (appData.debugMode)
3345                   fprintf(debugFP,
3346                           "Ratings from 'Game notification:' %s %d, %s %d\n",
3347                           player1Name, player1Rating,
3348                           player2Name, player2Rating);
3349
3350                 continue;
3351             }
3352
3353             /* Deal with automatic examine mode after a game,
3354                and with IcsObserving -> IcsExamining transition */
3355             if (looking_at(buf, &i, "Entering examine mode for game *") ||
3356                 looking_at(buf, &i, "has made you an examiner of game *")) {
3357
3358                 int gamenum = atoi(star_match[0]);
3359                 if ((gameMode == IcsIdle || gameMode == IcsObserving) &&
3360                     gamenum == ics_gamenum) {
3361                     /* We were already playing or observing this game;
3362                        no need to refetch history */
3363                     gameMode = IcsExamining;
3364                     if (pausing) {
3365                         pauseExamForwardMostMove = forwardMostMove;
3366                     } else if (currentMove < forwardMostMove) {
3367                         ForwardInner(forwardMostMove);
3368                     }
3369                 } else {
3370                     /* I don't think this case really can happen */
3371                     SendToICS(ics_prefix);
3372                     SendToICS("refresh\n");
3373                 }
3374                 continue;
3375             }
3376
3377             /* Error messages */
3378 //          if (ics_user_moved) {
3379             if (1) { // [HGM] old way ignored error after move type in; ics_user_moved is not set then!
3380                 if (looking_at(buf, &i, "Illegal move") ||
3381                     looking_at(buf, &i, "Not a legal move") ||
3382                     looking_at(buf, &i, "Your king is in check") ||
3383                     looking_at(buf, &i, "It isn't your turn") ||
3384                     looking_at(buf, &i, "It is not your move")) {
3385                     /* Illegal move */
3386                     if (ics_user_moved && forwardMostMove > backwardMostMove) { // only backup if we already moved
3387                         currentMove = forwardMostMove-1;
3388                         DisplayMove(currentMove - 1); /* before DMError */
3389                         DrawPosition(FALSE, boards[currentMove]);
3390                         SwitchClocks(forwardMostMove-1); // [HGM] race
3391                         DisplayBothClocks();
3392                     }
3393                     DisplayMoveError(_("Illegal move (rejected by ICS)")); // [HGM] but always relay error msg
3394                     ics_user_moved = 0;
3395                     continue;
3396                 }
3397             }
3398
3399             if (looking_at(buf, &i, "still have time") ||
3400                 looking_at(buf, &i, "not out of time") ||
3401                 looking_at(buf, &i, "either player is out of time") ||
3402                 looking_at(buf, &i, "has timeseal; checking")) {
3403                 /* We must have called his flag a little too soon */
3404                 whiteFlag = blackFlag = FALSE;
3405                 continue;
3406             }
3407
3408             if (looking_at(buf, &i, "added * seconds to") ||
3409                 looking_at(buf, &i, "seconds were added to")) {
3410                 /* Update the clocks */
3411                 SendToICS(ics_prefix);
3412                 SendToICS("refresh\n");
3413                 continue;
3414             }
3415
3416             if (!ics_clock_paused && looking_at(buf, &i, "clock paused")) {
3417                 ics_clock_paused = TRUE;
3418                 StopClocks();
3419                 continue;
3420             }
3421
3422             if (ics_clock_paused && looking_at(buf, &i, "clock resumed")) {
3423                 ics_clock_paused = FALSE;
3424                 StartClocks();
3425                 continue;
3426             }
3427
3428             /* Grab player ratings from the Creating: message.
3429                Note we have to check for the special case when
3430                the ICS inserts things like [white] or [black]. */
3431             if (looking_at(buf, &i, "Creating: * (*)* * (*)") ||
3432                 looking_at(buf, &i, "Creating: * (*) [*] * (*)")) {
3433                 /* star_matches:
3434                    0    player 1 name (not necessarily white)
3435                    1    player 1 rating
3436                    2    empty, white, or black (IGNORED)
3437                    3    player 2 name (not necessarily black)
3438                    4    player 2 rating
3439
3440                    The names/ratings are sorted out when the game
3441                    actually starts (below).
3442                 */
3443                 strcpy(player1Name, StripHighlightAndTitle(star_match[0]));
3444                 player1Rating = string_to_rating(star_match[1]);
3445                 strcpy(player2Name, StripHighlightAndTitle(star_match[3]));
3446                 player2Rating = string_to_rating(star_match[4]);
3447
3448                 if (appData.debugMode)
3449                   fprintf(debugFP,
3450                           "Ratings from 'Creating:' %s %d, %s %d\n",
3451                           player1Name, player1Rating,
3452                           player2Name, player2Rating);
3453
3454                 continue;
3455             }
3456
3457             /* Improved generic start/end-of-game messages */
3458             if ((tkind=0, looking_at(buf, &i, "{Game * (* vs. *) *}*")) ||
3459                 (tkind=1, looking_at(buf, &i, "{Game * (*(*) vs. *(*)) *}*"))){
3460                 /* If tkind == 0: */
3461                 /* star_match[0] is the game number */
3462                 /*           [1] is the white player's name */
3463                 /*           [2] is the black player's name */
3464                 /* For end-of-game: */
3465                 /*           [3] is the reason for the game end */
3466                 /*           [4] is a PGN end game-token, preceded by " " */
3467                 /* For start-of-game: */
3468                 /*           [3] begins with "Creating" or "Continuing" */
3469                 /*           [4] is " *" or empty (don't care). */
3470                 int gamenum = atoi(star_match[0]);
3471                 char *whitename, *blackname, *why, *endtoken;
3472                 ChessMove endtype = (ChessMove) 0;
3473
3474                 if (tkind == 0) {
3475                   whitename = star_match[1];
3476                   blackname = star_match[2];
3477                   why = star_match[3];
3478                   endtoken = star_match[4];
3479                 } else {
3480                   whitename = star_match[1];
3481                   blackname = star_match[3];
3482                   why = star_match[5];
3483                   endtoken = star_match[6];
3484                 }
3485
3486                 /* Game start messages */
3487                 if (strncmp(why, "Creating ", 9) == 0 ||
3488                     strncmp(why, "Continuing ", 11) == 0) {
3489                     gs_gamenum = gamenum;
3490                     strcpy(gs_kind, strchr(why, ' ') + 1);
3491                     VariantSwitch(boards[currentMove], StringToVariant(gs_kind)); // [HGM] variantswitch: even before we get first board
3492 #if ZIPPY
3493                     if (appData.zippyPlay) {
3494                         ZippyGameStart(whitename, blackname);
3495                     }
3496 #endif /*ZIPPY*/
3497                     partnerBoardValid = FALSE; // [HGM] bughouse
3498                     continue;
3499                 }
3500
3501                 /* Game end messages */
3502                 if (gameMode == IcsIdle || gameMode == BeginningOfGame ||
3503                     ics_gamenum != gamenum) {
3504                     continue;
3505                 }
3506                 while (endtoken[0] == ' ') endtoken++;
3507                 switch (endtoken[0]) {
3508                   case '*':
3509                   default:
3510                     endtype = GameUnfinished;
3511                     break;
3512                   case '0':
3513                     endtype = BlackWins;
3514                     break;
3515                   case '1':
3516                     if (endtoken[1] == '/')
3517                       endtype = GameIsDrawn;
3518                     else
3519                       endtype = WhiteWins;
3520                     break;
3521                 }
3522                 GameEnds(endtype, why, GE_ICS);
3523 #if ZIPPY
3524                 if (appData.zippyPlay && first.initDone) {
3525                     ZippyGameEnd(endtype, why);
3526                     if (first.pr == NULL) {
3527                       /* Start the next process early so that we'll
3528                          be ready for the next challenge */
3529                       StartChessProgram(&first);
3530                     }
3531                     /* Send "new" early, in case this command takes
3532                        a long time to finish, so that we'll be ready
3533                        for the next challenge. */
3534                     gameInfo.variant = VariantNormal; // [HGM] variantswitch: suppress sending of 'variant'
3535                     Reset(TRUE, TRUE);
3536                 }
3537 #endif /*ZIPPY*/
3538                 if(appData.bgObserve && partnerBoardValid) DrawPosition(TRUE, partnerBoard);
3539                 continue;
3540             }
3541
3542             if (looking_at(buf, &i, "Removing game * from observation") ||
3543                 looking_at(buf, &i, "no longer observing game *") ||
3544                 looking_at(buf, &i, "Game * (*) has no examiners")) {
3545                 if (gameMode == IcsObserving &&
3546                     atoi(star_match[0]) == ics_gamenum)
3547                   {
3548                       /* icsEngineAnalyze */
3549                       if (appData.icsEngineAnalyze) {
3550                             ExitAnalyzeMode();
3551                             ModeHighlight();
3552                       }
3553                       StopClocks();
3554                       gameMode = IcsIdle;
3555                       ics_gamenum = -1;
3556                       ics_user_moved = FALSE;
3557                   }
3558                 continue;
3559             }
3560
3561             if (looking_at(buf, &i, "no longer examining game *")) {
3562                 if (gameMode == IcsExamining &&
3563                     atoi(star_match[0]) == ics_gamenum)
3564                   {
3565                       gameMode = IcsIdle;
3566                       ics_gamenum = -1;
3567                       ics_user_moved = FALSE;
3568                   }
3569                 continue;
3570             }
3571
3572             /* Advance leftover_start past any newlines we find,
3573                so only partial lines can get reparsed */
3574             if (looking_at(buf, &i, "\n")) {
3575                 prevColor = curColor;
3576                 if (curColor != ColorNormal) {
3577                     if (oldi > next_out) {
3578                         SendToPlayer(&buf[next_out], oldi - next_out);
3579                         next_out = oldi;
3580                     }
3581                     Colorize(ColorNormal, FALSE);
3582                     curColor = ColorNormal;
3583                 }
3584                 if (started == STARTED_BOARD) {
3585                     started = STARTED_NONE;
3586                     parse[parse_pos] = NULLCHAR;
3587                     ParseBoard12(parse);
3588                     ics_user_moved = 0;
3589
3590                     /* Send premove here */
3591                     if (appData.premove) {
3592                       char str[MSG_SIZ];
3593                       if (currentMove == 0 &&
3594                           gameMode == IcsPlayingWhite &&
3595                           appData.premoveWhite) {
3596                         sprintf(str, "%s\n", appData.premoveWhiteText);
3597                         if (appData.debugMode)
3598                           fprintf(debugFP, "Sending premove:\n");
3599                         SendToICS(str);
3600                       } else if (currentMove == 1 &&
3601                                  gameMode == IcsPlayingBlack &&
3602                                  appData.premoveBlack) {
3603                         sprintf(str, "%s\n", appData.premoveBlackText);
3604                         if (appData.debugMode)
3605                           fprintf(debugFP, "Sending premove:\n");
3606                         SendToICS(str);
3607                       } else if (gotPremove) {
3608                         gotPremove = 0;
3609                         ClearPremoveHighlights();
3610                         if (appData.debugMode)
3611                           fprintf(debugFP, "Sending premove:\n");
3612                           UserMoveEvent(premoveFromX, premoveFromY,
3613                                         premoveToX, premoveToY,
3614                                         premovePromoChar);
3615                       }
3616                     }
3617
3618                     /* Usually suppress following prompt */
3619                     if (!(forwardMostMove == 0 && gameMode == IcsExamining)) {
3620                         while(looking_at(buf, &i, "\n")); // [HGM] skip empty lines
3621                         if (looking_at(buf, &i, "*% ")) {
3622                             savingComment = FALSE;
3623                             suppressKibitz = 0;
3624                         }
3625                     }
3626                     next_out = i;
3627                 } else if (started == STARTED_HOLDINGS) {
3628                     int gamenum;
3629                     char new_piece[MSG_SIZ];
3630                     started = STARTED_NONE;
3631                     parse[parse_pos] = NULLCHAR;
3632                     if (appData.debugMode)
3633                       fprintf(debugFP, "Parsing holdings: %s, currentMove = %d\n",
3634                                                         parse, currentMove);
3635                     if (sscanf(parse, " game %d", &gamenum) == 1) {
3636                       if(gamenum == ics_gamenum) { // [HGM] bughouse: old code if part of foreground game
3637                         if (gameInfo.variant == VariantNormal) {
3638                           /* [HGM] We seem to switch variant during a game!
3639                            * Presumably no holdings were displayed, so we have
3640                            * to move the position two files to the right to
3641                            * create room for them!
3642                            */
3643                           VariantClass newVariant;
3644                           switch(gameInfo.boardWidth) { // base guess on board width
3645                                 case 9:  newVariant = VariantShogi; break;
3646                                 case 10: newVariant = VariantGreat; break;
3647                                 default: newVariant = VariantCrazyhouse; break;
3648                           }
3649                           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
3650                           /* Get a move list just to see the header, which
3651                              will tell us whether this is really bug or zh */
3652                           if (ics_getting_history == H_FALSE) {
3653                             ics_getting_history = H_REQUESTED;
3654                             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3655                             SendToICS(str);
3656                           }
3657                         }
3658                         new_piece[0] = NULLCHAR;
3659                         sscanf(parse, "game %d white [%s black [%s <- %s",
3660                                &gamenum, white_holding, black_holding,
3661                                new_piece);
3662                         white_holding[strlen(white_holding)-1] = NULLCHAR;
3663                         black_holding[strlen(black_holding)-1] = NULLCHAR;
3664                         /* [HGM] copy holdings to board holdings area */
3665                         CopyHoldings(boards[forwardMostMove], white_holding, WhitePawn);
3666                         CopyHoldings(boards[forwardMostMove], black_holding, BlackPawn);
3667                         boards[forwardMostMove][HOLDINGS_SET] = 1; // flag holdings as set
3668 #if ZIPPY
3669                         if (appData.zippyPlay && first.initDone) {
3670                             ZippyHoldings(white_holding, black_holding,
3671                                           new_piece);
3672                         }
3673 #endif /*ZIPPY*/
3674                         if (tinyLayout || smallLayout) {
3675                             char wh[16], bh[16];
3676                             PackHolding(wh, white_holding);
3677                             PackHolding(bh, black_holding);
3678                             sprintf(str, "[%s-%s] %s-%s", wh, bh,
3679                                     gameInfo.white, gameInfo.black);
3680                         } else {
3681                             sprintf(str, "%s [%s] vs. %s [%s]",
3682                                     gameInfo.white, white_holding,
3683                                     gameInfo.black, black_holding);
3684                         }
3685                         if(!partnerUp) // [HGM] bughouse: when peeking at partner game we already know what he captured...
3686                         DrawPosition(FALSE, boards[currentMove]);
3687                         DisplayTitle(str);
3688                       } else if(appData.bgObserve) { // [HGM] bughouse: holdings of other game => background
3689                         sscanf(parse, "game %d white [%s black [%s <- %s",
3690                                &gamenum, white_holding, black_holding,
3691                                new_piece);
3692                         white_holding[strlen(white_holding)-1] = NULLCHAR;
3693                         black_holding[strlen(black_holding)-1] = NULLCHAR;
3694                         /* [HGM] copy holdings to partner-board holdings area */
3695                         CopyHoldings(partnerBoard, white_holding, WhitePawn);
3696                         CopyHoldings(partnerBoard, black_holding, BlackPawn);
3697                         if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual: always draw
3698                         if(partnerUp) DrawPosition(FALSE, partnerBoard);
3699                         if(twoBoards) { partnerUp = 0; flipView = !flipView; }
3700                       }
3701                     }
3702                     /* Suppress following prompt */
3703                     if (looking_at(buf, &i, "*% ")) {
3704                         if(strchr(star_match[0], 7)) SendToPlayer("\007", 1); // Bell(); // FICS fuses bell for next board with prompt in zh captures
3705                         savingComment = FALSE;
3706                         suppressKibitz = 0;
3707                     }
3708                     next_out = i;
3709                 }
3710                 continue;
3711             }
3712
3713             i++;                /* skip unparsed character and loop back */
3714         }
3715
3716         if (started != STARTED_MOVES && started != STARTED_BOARD && !suppressKibitz && // [HGM] kibitz
3717 //          started != STARTED_HOLDINGS && i > next_out) { // [HGM] should we compare to leftover_start in stead of i?
3718 //          SendToPlayer(&buf[next_out], i - next_out);
3719             started != STARTED_HOLDINGS && leftover_start > next_out) {
3720             SendToPlayer(&buf[next_out], leftover_start - next_out);
3721             next_out = i;
3722         }
3723
3724         leftover_len = buf_len - leftover_start;
3725         /* if buffer ends with something we couldn't parse,
3726            reparse it after appending the next read */
3727
3728     } else if (count == 0) {
3729         RemoveInputSource(isr);
3730         DisplayFatalError(_("Connection closed by ICS"), 0, 0);
3731     } else {
3732         DisplayFatalError(_("Error reading from ICS"), error, 1);
3733     }
3734 }
3735
3736
3737 /* Board style 12 looks like this:
3738
3739    <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
3740
3741  * The "<12> " is stripped before it gets to this routine.  The two
3742  * trailing 0's (flip state and clock ticking) are later addition, and
3743  * some chess servers may not have them, or may have only the first.
3744  * Additional trailing fields may be added in the future.
3745  */
3746
3747 #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"
3748
3749 #define RELATION_OBSERVING_PLAYED    0
3750 #define RELATION_OBSERVING_STATIC   -2   /* examined, oldmoves, or smoves */
3751 #define RELATION_PLAYING_MYMOVE      1
3752 #define RELATION_PLAYING_NOTMYMOVE  -1
3753 #define RELATION_EXAMINING           2
3754 #define RELATION_ISOLATED_BOARD     -3
3755 #define RELATION_STARTING_POSITION  -4   /* FICS only */
3756
3757 void
3758 ParseBoard12(string)
3759      char *string;
3760 {
3761     GameMode newGameMode;
3762     int gamenum, newGame, newMove, relation, basetime, increment, ics_flip = 0, i;
3763     int j, k, n, moveNum, white_stren, black_stren, white_time, black_time, takeback;
3764     int double_push, castle_ws, castle_wl, castle_bs, castle_bl, irrev_count;
3765     char to_play, board_chars[200];
3766     char move_str[500], str[500], elapsed_time[500];
3767     char black[32], white[32];
3768     Board board;
3769     int prevMove = currentMove;
3770     int ticking = 2;
3771     ChessMove moveType;
3772     int fromX, fromY, toX, toY;
3773     char promoChar;
3774     int ranks=1, files=0; /* [HGM] ICS80: allow variable board size */
3775     char *bookHit = NULL; // [HGM] book
3776     Boolean weird = FALSE, reqFlag = FALSE;
3777
3778     fromX = fromY = toX = toY = -1;
3779
3780     newGame = FALSE;
3781
3782     if (appData.debugMode)
3783       fprintf(debugFP, _("Parsing board: %s\n"), string);
3784
3785     move_str[0] = NULLCHAR;
3786     elapsed_time[0] = NULLCHAR;
3787     {   /* [HGM] figure out how many ranks and files the board has, for ICS extension used by Capablanca server */
3788         int  i = 0, j;
3789         while(i < 199 && (string[i] != ' ' || string[i+2] != ' ')) {
3790             if(string[i] == ' ') { ranks++; files = 0; }
3791             else files++;
3792             if(!strch