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