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