home *** CD-ROM | disk | FTP | other *** search
/ PC-Online 1996 May / PCOnline_05_1996.bin / linux / source / xap / gchess / xboard-3.0 / xboard-3 / xboard-3.0.pl9 / backend.c next >
C/C++ Source or Header  |  1993-09-09  |  111KB  |  4,254 lines
  1. /*
  2.  * backend.c -- Common back end for X and Windows NT versions of XBoard
  3.  * $Id: backend.c,v 1.22 1993/09/10 01:24:43 mann Exp $
  4.  *
  5.  * Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts.
  6.  * Enhancements Copyright 1992-93 Free Software Foundation, Inc.
  7.  *
  8.  * XBoard borrows its colors, icon and piece bitmaps from XChess
  9.  * which was written and is copyrighted by Wayne Christopher.
  10.  *
  11.  * The following terms apply to Digital Equipment Corporation's copyright
  12.  * interest in XBoard:
  13.  * ------------------------------------------------------------------------
  14.  * All Rights Reserved
  15.  *
  16.  * Permission to use, copy, modify, and distribute this software and its
  17.  * documentation for any purpose and without fee is hereby granted,
  18.  * provided that the above copyright notice appear in all copies and that
  19.  * both that copyright notice and this permission notice appear in
  20.  * supporting documentation, and that the name of Digital not be
  21.  * used in advertising or publicity pertaining to distribution of the
  22.  * software without specific, written prior permission.
  23.  *
  24.  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  25.  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  26.  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  27.  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  28.  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  29.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  30.  * SOFTWARE.
  31.  * ------------------------------------------------------------------------
  32.  *
  33.  * The following terms apply to the enhanced version of XBoard distributed
  34.  * by the Free Software Foundation:
  35.  * ------------------------------------------------------------------------
  36.  * This program is free software; you can redistribute it and/or modify
  37.  * it under the terms of the GNU General Public License as published by
  38.  * the Free Software Foundation; either version 2 of the License, or
  39.  * (at your option) any later version.
  40.  *
  41.  * This program is distributed in the hope that it will be useful,
  42.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  43.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  44.  * GNU General Public License for more details.
  45.  *
  46.  * You should have received a copy of the GNU General Public License
  47.  * along with this program; if not, write to the Free Software
  48.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  49.  * ------------------------------------------------------------------------
  50.  *
  51.  * See the file ChangeLog for a revision history.
  52.  */
  53.  
  54. #include <stdio.h>
  55. #include <ctype.h>
  56. #include <signal.h>
  57. #include <errno.h>
  58. #include <sys/types.h>
  59. #include <time.h>
  60. #if (defined(__STDC__) || defined(WIN32)) && !defined(ESIX)
  61. #include <stdlib.h>
  62. #endif
  63. #if defined(SYSTEM_FIVE) || defined(SYSV)
  64. #include <sys/types.h>
  65. #include <sys/stat.h>
  66. #ifdef AIXV3
  67. #include <fcntl.h>
  68. #else
  69. #include <sys/fcntl.h>
  70. #endif /*AIXV3*/
  71. #ifdef SVR4
  72. #include <stropts.h>
  73. #ifdef sun
  74. #include <sys/systeminfo.h>
  75. #endif
  76. #endif
  77. #endif
  78. #if defined(__STDC__) || defined(SYSTEM_FIVE) || defined(SYSV) || defined(sun) || defined(WIN32)
  79. #include <string.h>
  80. #else
  81. #include <strings.h>
  82. #endif
  83. #include <math.h>
  84.  
  85. #include "common.h"
  86. #include "frontend.h"
  87. #include "backend.h"
  88. #include "parser.h"
  89.  
  90. int establish P((void));
  91. void read_from_player P((InputSourceRef isr, char *buf, int count, int error));
  92. void read_from_ics P((InputSourceRef isr, char *buf, int count, int error));
  93. void SendToICS P((char *s));
  94. ChessSquare CharToPiece P((int c));
  95. char PieceToChar P((ChessSquare p));
  96. ChessSquare PromoPiece P((ChessMove moveType));
  97. ChessMove CoordsToAlgebraic P((int fromX, int fromY, int toX, int toY,
  98.                    int promoChar, int currentBoardIndex,
  99.                    char out[MOVE_LEN]));
  100. void InitPosition P((int redraw));
  101. void CopyBoard P((Board to, Board from));
  102. Boolean CompareBoards P((Board board1, Board board2));
  103. void SendCurrentBoard P((ProcRef pr));
  104. void SendBoard P((ProcRef pr, Board board));
  105. void FinishUserMove P((ChessMove moveType, int toX, int toY));
  106. void HandleMachineMove P((char *message, InputSourceRef isr));
  107. void LoadGameLoop P((void));
  108. int LoadGameOneMove P((void));
  109. int LoadGameFromFile P((char *filename, int n));
  110. int LoadPositionFromFile P((char *filename, int n));
  111. int SaveGameToFile P((char *filename));
  112. int SavePositionToFile P((char *filename));
  113. void ApplyMove P((ChessMove *moveType, int fromX, int fromY,
  114.           int toX, int toY, Board board));
  115. void MakeMove P((ChessMove *moveType, int fromX, int fromY,
  116.          int toX, int toY));
  117. void GameEnds P((char *message));
  118. void ShutdownChessPrograms P((char *message));
  119. void Reset P((int redraw));
  120. void EditPositionDone P((void));
  121. void PrintOpponents P((FILE *fp));
  122. void PrintPosition P((FILE *fp, int move));
  123. void InitChessProgram P((char *hostName, char *programName,
  124.              ProcRef *pr, InputSourceRef *isr, int *sendTime));
  125. void SendToProgram P((char *message, ProcRef pr));
  126. void ReceiveFromProgram P((InputSourceRef isr, char *buf, int count, int error));
  127. void SendSearchDepth P((ProcRef pr));
  128. void SendTimeRemaining P((ProcRef pr));
  129. void Attention P((ProcRef pr));
  130. char *StrStr P((char *string, char *match));
  131. int ToLower P((int c));
  132. int ToUpper P((int c));
  133.  
  134. Boolean ParseMachineMove P((char *machineMove, int moveNum,
  135.                 ChessMove *moveType, int *fromX, int *fromY,
  136.                 int *toX, int *toY, char *promoChar));
  137. void ParseGameHistory P((char *game));
  138. void ParseBoard8 P((char *string));
  139. void StartClocks P((void));
  140. void DisplayBothClocks P((void));
  141. void SwitchClocks P((void));
  142. void StopClocks P((void));
  143. void ResetClocks P((void));
  144.  
  145. /* States for ics_getting_history */
  146. #define H_FALSE 0
  147. #define H_REQUESTED 1
  148. #define H_GOT_REQ_HEADER 2
  149. #define H_GOT_UNREQ_HEADER 3
  150. #define H_GETTING_MOVES 4
  151.  
  152. FILE *gameFileFP,
  153.   *fromUserFP = stdin, *toUserFP = stdout, *debugFP = stderr;
  154.  
  155. int currentMove = 0, forwardMostMove = 0, backwardMostMove = 0,
  156.   firstMove = TRUE, flipView = FALSE,
  157.   blackPlaysFirst = FALSE, startedFromSetupPosition = FALSE,
  158.   searchTime = 0, pausing = FALSE,
  159.   whiteFlag = FALSE, blackFlag = FALSE, maybeThinking = FALSE, 
  160.   ics_user_moved = 0, ics_gamenum = -1,
  161.   ics_getting_history = H_FALSE, matchMode = FALSE;
  162. ProcRef firstProgramPR = NoProc, secondProgramPR = NoProc, icsPR = NoProc,
  163.   lastMsgPR = NoProc;
  164. InputSourceRef firstProgramISR = NULL, secondProgramISR = NULL,
  165.   telnetISR = NULL, fromUserISR = NULL;
  166. int firstSendTime = 2, secondSendTime = 2;  /* 0=don't, 1=do, 2=test first*/
  167. GameMode gameMode = BeginningOfGame, lastGameMode = BeginningOfGame;
  168. char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2],
  169.   ptyname[24], *chessDir, *programName, ics_black[32], ics_white[32],
  170.   endMessage[MOVE_LEN * 4];
  171. char *commentList[MAX_MOVES];
  172.  
  173. long whiteTimeRemaining, blackTimeRemaining, timeControl;
  174. long timeRemaining[2][MAX_MOVES];
  175. extern char currentMoveString[];
  176. #ifdef FLEX
  177. extern char *yytext;
  178. #else
  179. extern char yytext[];
  180. #endif
  181. extern int yyboardindex;
  182.      
  183. Board boards[MAX_MOVES], initialPosition = {
  184.     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
  185.     WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
  186.     { WhitePawn, WhitePawn, WhitePawn, WhitePawn,
  187.     WhitePawn, WhitePawn, WhitePawn, WhitePawn },
  188.     { EmptySquare, EmptySquare, EmptySquare, EmptySquare,
  189.     EmptySquare, EmptySquare, EmptySquare, EmptySquare },
  190.     { EmptySquare, EmptySquare, EmptySquare, EmptySquare,
  191.     EmptySquare, EmptySquare, EmptySquare, EmptySquare },
  192.     { EmptySquare, EmptySquare, EmptySquare, EmptySquare,
  193.     EmptySquare, EmptySquare, EmptySquare, EmptySquare },
  194.     { EmptySquare, EmptySquare, EmptySquare, EmptySquare,
  195.     EmptySquare, EmptySquare, EmptySquare, EmptySquare },
  196.     { BlackPawn, BlackPawn, BlackPawn, BlackPawn,
  197.     BlackPawn, BlackPawn, BlackPawn, BlackPawn },
  198.     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
  199.     BlackKing, BlackBishop, BlackKnight, BlackRook }
  200. };
  201.  
  202. AppData appData;
  203.  
  204. char pieceToChar[] = {
  205.     'P', 'R', 'N', 'B', 'Q', 'K',
  206.     'p', 'r', 'n', 'b', 'q', 'k', '.'
  207.   };
  208.  
  209. void InitBackEnd1()
  210. {
  211.     char buf[MSG_SIZ];
  212.     int matched, min, sec;
  213.  
  214.     /*
  215.      * Internet chess server status
  216.      */
  217.     if (appData.icsActive) {
  218.     appData.matchMode = FALSE;
  219.     appData.noChessProgram = TRUE;
  220.     }
  221.  
  222.     /*
  223.      * Parse timeControl resource
  224.      */
  225.     if (!ParseTimeControl(appData.timeControl)) {
  226.     sprintf(buf, "Bad timeControl option %s",
  227.         appData.timeControl);
  228.     DisplayFatalError(buf, 0);
  229.     ExitEvent(2);
  230.     }
  231.     if (appData.icsActive) timeControl = 0;
  232.     
  233.     /*
  234.      * Parse searchTime resource
  235.      */
  236.     if (*appData.searchTime != NULLCHAR) {
  237.     matched = sscanf(appData.searchTime, "%d:%d", &min, &sec);
  238.     if (matched == 1) {
  239.         searchTime = min * 60;
  240.     } else if (matched == 2) {
  241.         searchTime = min * 60 + sec;
  242.     } else {
  243.         sprintf(buf, "Bad searchTime option %s",
  244.             appData.searchTime);
  245.         DisplayFatalError(buf, 0);
  246.         ExitEvent(2);
  247.     }
  248.     }
  249.     
  250.     if ((*appData.searchTime != NULLCHAR) || (appData.searchDepth > 0)
  251.     || appData.noChessProgram)
  252.       appData.clockMode = FALSE;
  253.     if (appData.icsActive) appData.clockMode = TRUE;
  254. }
  255.  
  256. int ParseTimeControl(tc)
  257.      char *tc;
  258. {
  259.     int matched, min, sec;
  260.  
  261.     matched = sscanf(tc, "%d:%d", &min, &sec);
  262.     if (matched == 1) {
  263.     timeControl = min * 60 * 1000;
  264.     } else if (matched == 2) {
  265.     timeControl = (min * 60 + sec) * 1000;
  266.     } else {
  267.     return FALSE;
  268.     }
  269.     return TRUE;
  270. }
  271.  
  272. void InitBackEnd2()
  273. {
  274.     char buf[MSG_SIZ];
  275.     int err;
  276.  
  277.     if (appData.icsActive) {
  278.     err = establish();
  279.     if (err != 0) {
  280.         sprintf(buf,
  281.             "Could not connect to host %s, port %d",  
  282.             appData.icsHost, appData.icsPort);
  283.         DisplayFatalError(buf, err);
  284.         ExitEvent(1);
  285.     }
  286.     SetICSMode();
  287.     telnetISR = AddInputSource(icsPR, FALSE, read_from_ics);
  288.     fromUserISR = AddInputSource(NoProc, FALSE, read_from_player);
  289.     } else {
  290.     if (appData.noChessProgram)
  291.       SetNCPMode();
  292.     else
  293.       SetGNUMode();
  294.     }
  295.  
  296.     /*
  297.      * If there is to be a machine match, set it up.
  298.      */
  299.     if (appData.matchMode) {
  300.     if (appData.noChessProgram) {
  301.         DisplayFatalError("Can't have a match with no chess programs", 0);
  302.         ExitEvent(2);
  303.     }
  304.     Reset(TRUE);
  305.     matchMode = TRUE;
  306.     if (*appData.loadGameFile != NULLCHAR) {
  307.         if (!LoadGameFromFile(appData.loadGameFile,
  308.                   appData.loadGameIndex)) {
  309.         DisplayFatalError("Bad game file", 0);
  310.         ExitEvent(1);
  311.         }
  312.     } else if (*appData.loadPositionFile != NULLCHAR) {
  313.         if (!LoadPositionFromFile(appData.loadPositionFile,
  314.                       appData.loadPositionIndex)) {
  315.         DisplayFatalError("Bad position file", 0);
  316.         ExitEvent(1);
  317.         }
  318.     }
  319.     TwoMachinesEvent();
  320.     } else {
  321.     Reset(TRUE);
  322.     if (*appData.loadGameFile != NULLCHAR) {
  323.         (void) LoadGameFromFile(appData.loadGameFile,
  324.                     appData.loadGameIndex);
  325.     } else if (*appData.loadPositionFile != NULLCHAR) {
  326.         (void) LoadPositionFromFile(appData.loadPositionFile,
  327.                     appData.loadPositionIndex);
  328.     }
  329.     }
  330. }
  331.  
  332. /*
  333.  * Establish will establish a contact to a remote host.port.
  334.  * Sets icsPR to a ProcRef for a process (or pseudo-process)
  335.  *  used to talk to the host.
  336.  * Returns 0 if okay, error code if not.
  337.  */
  338. int establish()
  339. {
  340.     char buf[MSG_SIZ];
  341.  
  342.     if (*appData.icsCommPort != NULLCHAR) {
  343.     /* Talk to the host through a serial comm port */
  344.     Raw();
  345.     return OpenCommPort(appData.icsCommPort, &icsPR);
  346.  
  347.     } else if (*appData.gateway != NULLCHAR) {
  348.     /* Use rsh to run telnet program on a gateway host */
  349.     sprintf(buf, "%s %s %s %s %d", appData.remoteShell,
  350.         appData.gateway, appData.telnetProgram,
  351.         appData.icsHost, appData.icsPort);
  352.     return StartChildProcess(buf, &icsPR);
  353.  
  354.     } else if (appData.useTelnet) {
  355.     Raw();
  356.     return OpenTelnet(appData.icsHost, appData.icsPort, &icsPR);
  357.  
  358.     } else {
  359.     /* TCP socket interface differs somewhat between
  360.        Unix and NT; handle details in the front end.
  361.     */
  362.     return OpenTCP(appData.icsHost, appData.icsPort, &icsPR);
  363.     }
  364. }
  365.  
  366. void read_from_player(isr, message, count, error)
  367.      InputSourceRef isr;
  368.      char *message;
  369.      int count;
  370.      int error;
  371. {
  372.     int outError, outCount;
  373.  
  374.     if (count > 0) {
  375.     outCount = OutputToProcess(icsPR, message, count, &outError);
  376.     if (outCount < count) {
  377.         DisplayFatalError("Error writing to ICS", outError);
  378.         ExitEvent(1);
  379.     }
  380.     } else if (count < 0) {
  381.     DisplayFatalError("Error reading from keyboard", error);
  382.     ExitEvent(1);
  383.     } else {
  384.     DisplayFatalError("Got end of file from keyboard", 0);
  385.     ExitEvent(0);
  386.     }
  387. }
  388.  
  389.  
  390. void SendToICS(s)
  391.      char *s;
  392. {
  393.     int count, outCount, outError;
  394.  
  395.     if (appData.debugMode)
  396.       fprintf(debugFP, "Sending to ICS: %s", s);
  397.  
  398.     count = strlen(s);
  399.     outCount = OutputToProcess(icsPR, s, count, &outError);
  400.     if (outCount < count) {
  401.     DisplayFatalError("Error writing to ICS", outError);
  402.     ExitEvent(1);
  403.     }
  404. }
  405.  
  406.  
  407. static int leftover_start = 0, leftover_len = 0;
  408. char star_match[STAR_MATCH_N][MSG_SIZ];
  409.  
  410. /* Test whether pattern is present at &buf[*index]; if so, return TRUE,
  411.    advance *index beyond it, and set leftover_start to the new value of
  412.    *index; else return FALSE.  If pattern contains the character '*', it
  413.    matches any sequence of characters not containing '\r', '\n', or the
  414.    character following the '*' (if any), and the matched sequence(s) are
  415.    copied into star_match.
  416. */
  417. int looking_at(buf, index, pattern)
  418.      char *buf;
  419.      int *index;
  420.      char *pattern;
  421. {
  422.     char *bufp = &buf[*index], *patternp = pattern;
  423.     int star_count = 0;
  424.     char *matchp = star_match[0];
  425.     
  426.     for (;;) {
  427.     if (*patternp == NULLCHAR) {
  428.         *index = leftover_start = bufp - buf;
  429.         *matchp = NULLCHAR;
  430.         return TRUE;
  431.     }
  432.     if (*bufp == NULLCHAR) return FALSE;
  433.     if (*patternp == '*') {
  434.         if (*bufp == *(patternp + 1)) {
  435.         *matchp = NULLCHAR;
  436.         matchp = star_match[++star_count];
  437.         patternp += 2;
  438.         bufp++;
  439.         continue;
  440.         } else if (*bufp == '\n' || *bufp == '\r') {
  441.         patternp++;
  442.         if (*patternp == NULLCHAR)
  443.           continue;
  444.         else
  445.           return FALSE;
  446.         } else {
  447.         *matchp++ = *bufp++;
  448.         continue;
  449.         }
  450.     }
  451.     if (*patternp != *bufp) return FALSE;
  452.     patternp++;
  453.     bufp++;
  454.     }
  455. }
  456.  
  457.  
  458. void read_from_ics(isr, data, count, error)
  459.      InputSourceRef isr;
  460.      char *data;
  461.      int count;
  462.      int error;
  463. {
  464. #define BUF_SIZE 8192
  465. #define STARTED_NONE 0
  466. #define STARTED_BOARD 1
  467. #define STARTED_MOVES 2
  468.     
  469.     static int started = STARTED_NONE;
  470.     static char parse[20000];
  471.     static int  parse_pos;
  472.     static char buf[BUF_SIZE + 1];
  473.     
  474.     char str[500];
  475.     int i, oldi;
  476.     int buf_len;
  477.     int next_out;
  478.     
  479.     if (count > 0) {
  480.     /* If last read ended with a partial line that we couldn't parse,
  481.        prepend it to the new read and try again. */
  482.     if (leftover_len > 0) {
  483.         for (i=0; i<leftover_len; i++)
  484.           buf[i] = buf[leftover_start + i];
  485.     }
  486.  
  487.     memcpy(&buf[leftover_len], data, count);
  488.     buf_len = count + leftover_len;
  489.     buf[buf_len] = NULLCHAR;
  490.     next_out = leftover_len;
  491.     leftover_start = 0;
  492.     
  493.     i = 0;
  494.     while (i < buf_len) {
  495.         
  496. #ifdef ZIPPY
  497.         if (ZippyConverse(buf, &i)) continue;
  498. #else
  499.         /* Skip over what people say */
  500.         if (looking_at(buf, &i, "shouts: *") ||
  501.         looking_at(buf, &i, "tells you: *") ||
  502.         looking_at(buf, &i, "says: *") ||
  503.         looking_at(buf, &i, "whispers: *") ||
  504.         looking_at(buf, &i, "kibitzes: *")) {
  505.         continue;
  506.         }
  507. #endif /*ZIPPY*/
  508.  
  509. #define WILL_ECHO "\377\373\1"
  510. #define WONT_ECHO "\377\374\1"
  511. #define DO_ECHO   "\377\375\1"
  512. #define DONT_ECHO "\377\376\1"
  513.  
  514.         /* Kludge to deal with part of TELNET protocol */
  515.         if (looking_at(buf, &i, WILL_ECHO)) {
  516.         SendToICS(DO_ECHO);
  517.         EchoOff();
  518.         }
  519.         if (looking_at(buf, &i, WONT_ECHO)) {
  520.         SendToICS(DONT_ECHO);
  521.         EchoOn();
  522.         }
  523.  
  524.         if (looking_at(buf, &i,
  525.                "a   b   c   d   e   f   g   h") || 
  526.         looking_at(buf, &i,
  527.                "h   g   f   e   d   c   b   a")) {
  528.         /* End of board style 1 */
  529.         SendToICS("set style 8\n");
  530.                 SendToICS("refresh\n");
  531.         continue;
  532.         }
  533.         
  534.         oldi = i;
  535.         if (looking_at(buf, &i, "#@#")) {
  536.         started = STARTED_BOARD;
  537.         parse_pos = 0;
  538.         if (oldi > next_out)
  539.           fwrite(&buf[next_out], oldi - next_out, 1, toUserFP);
  540.         continue;
  541.         }
  542.         
  543.         if (started == STARTED_BOARD && looking_at(buf, &i, "@#@")) {
  544.         /* Board read is done */
  545.         started = STARTED_NONE;
  546.         next_out = i;
  547.         parse[parse_pos] = NULLCHAR;
  548.         
  549.         /* Parse and display the board */
  550.         ParseBoard8(parse);
  551.         
  552.         ics_user_moved = 0;
  553.         continue;
  554.         }
  555.         
  556.         if (looking_at(buf, &i, "* *vs. * *--- *")) {
  557.         /* Header for a move list -- first line */
  558.         /* We might want to save some of these fields but
  559.            for now we don't */
  560.         switch (ics_getting_history) {
  561.           case H_FALSE:
  562.             switch (gameMode) {
  563.               case IcsIdle:
  564.               case BeginningOfGame:
  565.             /* User typed "moves" or "oldmoves" while we
  566.                were idle.  Pretend we asked for these
  567.                moves and soak them up so user can step
  568.                through them and/or save them.
  569.             */
  570.             Reset(FALSE);
  571.             gameMode = IcsObserving;
  572.             ModeHighlight();
  573.             ics_gamenum = -1;
  574.             ics_getting_history = H_GOT_REQ_HEADER;
  575.             break;
  576.               case ForceMoves: /*?*/
  577.               case EditPosition: /*?*/
  578.             /* Should above feature work in these modes too? */
  579.             /* For now it doesn't */
  580.             ics_getting_history = H_GOT_UNREQ_HEADER;
  581.             break;
  582.               default:
  583.             ics_getting_history = H_GOT_UNREQ_HEADER;
  584.             break;
  585.             }
  586.             break;
  587.           case H_REQUESTED:
  588.             /* All is well */
  589.             ics_getting_history = H_GOT_REQ_HEADER;
  590.             break;
  591.           case H_GOT_REQ_HEADER:
  592.           case H_GOT_UNREQ_HEADER:
  593.           case H_GETTING_MOVES:
  594.             /* Should not happen */
  595.             DisplayError("Error gathering move list", 0);
  596.             ics_getting_history = H_GOT_UNREQ_HEADER;
  597.             break;
  598.         }
  599.         continue;
  600.         }
  601.  
  602.         if (looking_at(buf, &i,
  603.               "* * match, initial time: * minutes, increment: * seconds.")) {
  604.         /* Header for a move list -- second line */
  605.         /* Initial board will follow if this is a wild game */
  606.         /* Again, we might want to save some of these fields later */
  607.         /* For now we do nothing with them. */
  608.         continue;
  609.         }
  610.  
  611.         oldi = i;
  612.         if (looking_at(buf, &i, "Move  ")) {
  613.         /* Beginning of a move list */
  614.         switch (ics_getting_history) {
  615.           case H_FALSE:
  616.             /* Normally should not happen */
  617.             /* Maybe user hit reset while we were parsing */
  618.             break;
  619.           case H_REQUESTED:
  620.           case H_GETTING_MOVES:
  621.             /* Should not happen */
  622.             DisplayError("Error gathering move list", 0);
  623.             break;
  624.           case H_GOT_REQ_HEADER:
  625.             ics_getting_history = H_GETTING_MOVES;
  626.             started = STARTED_MOVES;
  627.             parse_pos = 0;
  628.             if (oldi > next_out)
  629.               fwrite(&buf[next_out], oldi - next_out, 1, toUserFP);
  630.             break;
  631.           case H_GOT_UNREQ_HEADER:
  632.             ics_getting_history = H_FALSE;
  633.             break;
  634.         }
  635.         continue;
  636.         }                
  637.         
  638.         if(looking_at(buf, &i, "% ")) {
  639.         switch (started) {
  640.           case STARTED_NONE:
  641. #ifdef ZIPPY
  642.             ZippyPeriodic();
  643. #endif /*ZIPPY*/
  644.             continue;
  645.           case STARTED_BOARD:
  646.             /* Something went wrong; found a prompt while
  647.                accumulating a board */
  648.             started = STARTED_NONE;
  649.             DisplayError("Error gathering board", 0);
  650.             continue;
  651.           case STARTED_MOVES:
  652.             started = STARTED_NONE;
  653.             parse[parse_pos] = NULLCHAR;
  654.             ParseGameHistory(parse);
  655.              if (gameMode == IcsObserving && ics_gamenum == -1) {
  656.             /* Moves came from oldmoves or moves command
  657.                while we weren't doing anything else.
  658.             */
  659.             currentMove = forwardMostMove;
  660.             flipView = appData.flipView;
  661.             DrawPosition(FALSE, boards[currentMove]);
  662.             DisplayBothClocks();
  663.             sprintf(str, "%s vs. %s", ics_white, ics_black);
  664.             DisplayTitle(str);
  665.             gameMode = IcsIdle;
  666.             }
  667.             DisplayMove(currentMove - 1);
  668.             SendToICS("\n");  /*kludge: force a prompt*/
  669.             next_out = i;
  670.             ics_getting_history = H_FALSE;
  671.             continue;
  672.         }
  673.         }
  674.         
  675.         if (started != STARTED_NONE && i >= leftover_len) {
  676.         /* Accumulate characters in board
  677.            or move list*/
  678.         if (buf[i] != '\r' && buf[i] != NULLCHAR)
  679.           parse[parse_pos++] = buf[i];
  680.         }
  681.         
  682.         /* Start of game messages.  Mostly we detect start of game
  683.            when the first board image arrives, but we need to prime
  684.            the pump for games we're just observing. */
  685.         if (looking_at(buf, &i, "Adding game * to observation list")) {
  686.         sprintf(str, "refresh %d\n", atoi(star_match[0]));
  687.         SendToICS(str);
  688.         continue;
  689.         }
  690.         
  691.         /* Error messages */
  692.         if (ics_user_moved) {
  693.         if (looking_at(buf, &i, "No such command") ||
  694.             looking_at(buf, &i, "Illegal move") ||
  695.             looking_at(buf, &i, "Not a legal move") ||
  696.             looking_at(buf, &i, "Your king is in check") ||
  697.             looking_at(buf, &i, "It isn't your turn")) {
  698.             /**** Illegal move ****/
  699.             ics_user_moved = 0;
  700.             if (forwardMostMove > backwardMostMove) {
  701.             currentMove = --forwardMostMove;
  702.             DisplayError("Illegal move", 0);
  703.             DrawPosition(FALSE, boards[currentMove]);
  704.             SwitchClocks();
  705.             }
  706.             continue;
  707.         }
  708.         }
  709.  
  710.         if (looking_at(buf, &i, "You and your opponent still have time")) {
  711.         /* We must have called his flag a little too soon */
  712.         whiteFlag = blackFlag = FALSE;
  713.         continue;
  714.         }
  715.  
  716.         /* Start/end-of-game messages */
  717.         if (looking_at(buf, &i, "{Game * (* vs. *)* * *}")) {
  718.         /* New style generic game start/end messages */
  719.         /* star_match[0] is the game number */
  720.         /*           [1] is the white player's name */
  721.         /*           [2] is the black player's name */
  722.         /*           [3] is either ":" or empty (don't care) */
  723.         /*           [4] is usually the loser's name or a noise word */
  724.         /*           [5] contains the reason for the game end */
  725.         int gamenum = atoi(star_match[0]);
  726.         char *white = star_match[1];
  727.         char *loser = star_match[4];
  728.         char *why = star_match[5];
  729.         
  730. #ifdef ZIPPY
  731.         /* Game start messages */
  732.         if (strcmp(loser, "Creating") == 0 ||
  733.             strcmp(loser, "Continuing") == 0) {
  734.             ZippyGameStart(white, star_match[2]);
  735.             continue;
  736.         }
  737. #endif /*ZIPPY*/
  738.  
  739.         /* Game end messages */
  740.         if (ics_gamenum != gamenum) continue;
  741.  
  742.         if (StrStr(why, "checkmate")) {
  743.             if (strcmp(loser, white) == 0)
  744.               GameEnds("Black mates");
  745.             else
  746.               GameEnds("White mates");
  747.         } else if (StrStr(why, "resign")) {
  748.             if (strcmp(loser, white) == 0)
  749.               GameEnds("White resigns");
  750.             else
  751.               GameEnds("Black resigns");
  752.         } else if (StrStr(why, "forfeits on time")) {
  753.             if (strcmp(loser, white) == 0)
  754.               GameEnds("Black wins on time");
  755.             else
  756.               GameEnds("White wins on time");
  757.         } else if (StrStr(why, "stalemate")) {
  758.             GameEnds("Stalemate");
  759.         } else if (StrStr(why, "drawn by mutual agreement")) {
  760.             GameEnds("Draw agreed");
  761.         } else if (StrStr(why, "repetition")) {
  762.             GameEnds("Draw by repetition");
  763.         } else if (StrStr(why, "50")) {
  764.             GameEnds("Draw (50 move rule)");
  765.         } else if (StrStr(why, "neither player has mating")) {
  766.             GameEnds("Draw (insufficient material)");
  767.         } else if (StrStr(why, "no material")) {
  768.             GameEnds("Draw (insufficient material to win on time)");
  769.         } else if (StrStr(why, "time")) {
  770.             GameEnds("Draw (both players ran out of time)");
  771.         } else if (StrStr(why, "disconnected and forfeits")) {
  772.             /* in this case the word "abuser" preceded the loser */
  773.             loser = why;
  774.             why = strchr(loser, ' ');
  775.             *why++ = NULLCHAR;
  776.             if (strcmp(loser, white) == 0)
  777.               GameEnds("Black wins (forfeit)");
  778.             else
  779.               GameEnds("White wins (forfeit)");
  780.         } else if (StrStr(why, "assert")) {
  781.             /* "loser" is actually the winner in this case */
  782.             if (strcmp(loser, white) == 0)
  783.               GameEnds("White asserts a win");
  784.             else
  785.               GameEnds("Black asserts a win");
  786.         } else if (StrStr(why, "aborted")) {
  787.             GameEnds("Game aborted");
  788.         } else if (StrStr(why, "removed")) {
  789.             GameEnds("Game aborted");
  790.         } else if (StrStr(why, "adjourn")) {
  791.             GameEnds("Game adjourned");
  792.         }   
  793.         continue;
  794.         }
  795.  
  796.         if (looking_at(buf, &i, "Removing game * from observation list")) {
  797.         if (gameMode == IcsObserving &&
  798.             atoi(star_match[0]) == ics_gamenum)
  799.           {
  800.               StopClocks();
  801.               gameMode = IcsIdle;
  802.               ics_gamenum = -1;
  803.               ics_user_moved = FALSE;
  804.           }
  805.         continue;
  806.         }
  807.  
  808.         /* Advance leftover_start past any newlines we find,
  809.            so only partial lines can get reparsed */
  810.         if (looking_at(buf, &i, "\n")) continue;
  811.         if (looking_at(buf, &i, "\r")) {
  812. #ifdef WIN32
  813.         /* Kludge; change \r\000 to \r\r */
  814.         if (i < buf_len && buf[i] == NULLCHAR) buf[i++] = '\r';
  815. #endif
  816.         continue;
  817.         }
  818.  
  819.         i++;    /* skip unparsed character and loop back */
  820.     }
  821.     
  822.     if (started == STARTED_NONE && i > next_out)
  823.       fwrite(&buf[next_out], i - next_out, 1, toUserFP);
  824.     
  825.     leftover_len = buf_len - leftover_start;
  826.     /* if buffer ends with something we couldn't parse,
  827.        reparse it after appending the next read */
  828.     
  829.     } else if (count == 0) {
  830.     DisplayFatalError("Connection closed by ICS", 0);
  831.     ExitEvent(0);
  832.     } else {
  833.     DisplayFatalError("Error reading from ICS", error);
  834.     ExitEvent(1);
  835.     }
  836. }
  837.  
  838. /*
  839.   ICS board style 8 looks like this:
  840.   
  841.   #@#000observer        :aaa             :RNBQKBNRPPPPPPPP                                pppppppprnbqkbnr001W39390360003600@#@
  842.   
  843.   Information offsets, descriptions and lengths:
  844.   +3   Game # (3)
  845.   +6   White's name (16 + ':' = 17)
  846.   +23  Black's name (16 + ':' = 17)
  847.   +40  Board  (64)
  848.   +104 Move # (3)
  849.   +107 Whose move (1)
  850.   +108 White Strength (2)
  851.   +110 Black Strength (2)
  852.   +112 White Time (5)
  853.   +117 Black Time (5)
  854.   +122 Move string (variable
  855.   A "*" instead of a ":" after the name implies that the person using xboard
  856.     is playing the game.
  857.   The move string is either empty or consists of a move followed by
  858.     elapsed time in parentheses.
  859.   The pattern defined below doesn't include the #@# and @#@ brackets,
  860.     and it assumes the board string is null-terminated.  ParseBoard8's
  861.     caller takes care of this.
  862.   */
  863.  
  864. #define PATTERN "%3d%16s %1c%16s %1c%64c%3d%1c%2d%2d%5d%5d%s %s"
  865.  
  866. void ParseBoard8(string)
  867.      char *string;
  868. { 
  869.     GameMode newGameMode;
  870.     int gamenum;
  871.     int j, k, n, moveNum, white_stren, black_stren, white_time, black_time;
  872.     char playing_white, playing_black, to_play, board_chars[64];
  873.     char move_str[500], str[500], elapsed_time[500];
  874.     char black[32], white[32];
  875.     Board board;
  876.     
  877.     if (appData.debugMode)
  878.       fprintf(debugFP, "Parsing board: %s\n", string);
  879.  
  880.     move_str[0] = NULLCHAR;
  881.     elapsed_time[0] = NULLCHAR;
  882.     n = sscanf(string, PATTERN, &gamenum, white, &playing_white,
  883.            black, &playing_black, board_chars, &moveNum, &to_play,
  884.            &white_stren, &black_stren, &white_time, &black_time,
  885.            move_str, elapsed_time);
  886.     if (n < 12) {
  887.     sprintf(str, "Failed to parse board string: \"%s\"", string);
  888.     DisplayError(str, 0);
  889.     return;
  890.     }
  891.  
  892.     if (playing_white == '*')
  893.       newGameMode = IcsPlayingWhite;
  894.     else if (playing_black == '*')
  895.       newGameMode = IcsPlayingBlack;
  896.     else
  897.       newGameMode = IcsObserving;
  898.     
  899.     /* Convert the move number to internal form */
  900.     moveNum = (moveNum - 1) * 2;
  901.     if (to_play == 'B') moveNum++;
  902.  
  903.     /* Deal with initial board display on move listing
  904.        of wild games.
  905.     */
  906.     switch (ics_getting_history) {
  907.       case H_FALSE:
  908.       case H_REQUESTED:
  909.     break;
  910.       case H_GOT_REQ_HEADER:
  911.     /* This is an initial board that we want */
  912.     gamenum = ics_gamenum;
  913.     moveNum = 0; /* !! ICS bug workaround */
  914.     break;
  915.       case H_GOT_UNREQ_HEADER:
  916.     /* This is an initial board that we don't want */
  917.     return;
  918.       case H_GETTING_MOVES:
  919.     /* Should not happen */
  920.     DisplayError("Error gathering move list", 0);
  921.     return;
  922.     }
  923.  
  924.     /* Take action if this is the first board of a new game */
  925.     if (gamenum != ics_gamenum) {
  926.     /* Check if trying to do two things at once */
  927.     if (gameMode == IcsObserving) {
  928.         /* Error: xboard can't handle two games at once */
  929.         /* Stop observing the old game */
  930.         sprintf(str, "observe %d\n", ics_gamenum);
  931.         SendToICS(str);
  932.         sprintf(str, "Aren't you observing game %d?  Attempting to stop observing it.",
  933.             ics_gamenum);
  934.         DisplayError(str, 0);
  935.         /* continue as in normal case */
  936.     } else if (gameMode == IcsPlayingBlack || gameMode == IcsPlayingWhite) {
  937.         /* Error: xboard can't handle two games at once */
  938.         if (newGameMode == IcsObserving) {
  939.         /* Stop observing the new game */
  940.         SendToICS("observe\n");
  941.         sprintf(str, "Aren't you playing a game?  Attempting to stop observing game %d.",
  942.             gamenum);
  943.         DisplayError(str, 0);
  944.         /* ignore this board */
  945.         return;
  946.         } else /* newGameMode == IcsPlaying(White|Black) */ {
  947.         /* Playing two games???  ICS supposedly can't do this. */
  948.         sprintf(str, "BUG: playing two games at once (%d and %d)",
  949.             ics_gamenum, gamenum);
  950.         DisplayError(str, 0);
  951.         /* continue as in normal case, hoping old game is gone */
  952.         }
  953.     }
  954.     /* Normal case, or error recovered */
  955.     Reset(FALSE);
  956.     if (moveNum > 0) {
  957.         /* Need to get game history */
  958.         ics_getting_history = H_REQUESTED;
  959.         sprintf(str, "moves %d\n", gamenum);
  960.         SendToICS(str);
  961.     }
  962.     }
  963.  
  964.     /* Initially flip the board to have black on the bottom iff playing
  965.        black, but let the user change it with the Flip View button. */
  966.     if (gameMode == IcsIdle || gameMode == BeginningOfGame)
  967.       flipView = (newGameMode == IcsPlayingBlack);
  968.  
  969.     /* Update known move number limits */
  970.     if (gameMode == IcsIdle || gameMode == BeginningOfGame) {
  971.     forwardMostMove = backwardMostMove = currentMove = moveNum;
  972.     } else if (moveNum > forwardMostMove) {
  973.     forwardMostMove = moveNum;
  974.     if (!pausing) 
  975.       currentMove = moveNum;
  976.     }
  977.  
  978.     /* Done with values from previous mode; copy in new ones */
  979.     gameMode = newGameMode;
  980.     ModeHighlight();
  981.     ics_gamenum = gamenum;
  982.     strcpy(ics_white, white);
  983.     strcpy(ics_black, black);
  984.  
  985.     /* Parse the board */
  986.     for (k = 0; k < 8; k++)
  987.       for (j = 0; j < 8; j++)
  988.     board[k][j] = CharToPiece(board_chars[k*8 + j]);
  989.     CopyBoard(boards[moveNum], board);
  990.     if (moveNum == 0) {
  991.     startedFromSetupPosition =
  992.       !CompareBoards(board, initialPosition);
  993.     }
  994.     
  995.     /* Put the move on the move list, first converting
  996.        to canonical algebraic form. */
  997.     if (moveNum > 0) {
  998.     ChessMove moveType;
  999.     int fromX, fromY, toX, toY;
  1000.     char promoChar;
  1001.  
  1002.     if (moveNum - 1 < backwardMostMove) {
  1003.         /* We don't know what the board looked like before
  1004.            this move.  Punt. */
  1005.         strcpy(parseList[moveNum - 1], move_str);
  1006.     } else {
  1007.         if (ParseMachineMove(move_str, moveNum - 1, &moveType,
  1008.                  &fromX, &fromY, &toX, &toY, &promoChar)) {
  1009.         /* Work around ICS bug: pawn promotion is not indicated,
  1010.            even if underpromoted.  Unfortunately there is no
  1011.            workaround for the same bug when it bites us in
  1012.            ParseGameHistory().
  1013.            */
  1014.         if (move_str[0] == 'P' && (toY == 0 || toY == 7))
  1015.           promoChar = ToLower(PieceToChar(board[toY][toX]));
  1016.  
  1017.         (void) CoordsToAlgebraic(fromX, fromY, toX, toY, promoChar,
  1018.                      moveNum - 1, parseList[moveNum - 1]);
  1019.         strcat(parseList[moveNum - 1], " ");
  1020.         strcat(parseList[moveNum - 1], elapsed_time);
  1021.         } else {
  1022.         /* Move from ICS was illegal!?  Punt. */
  1023.         strcpy(parseList[moveNum - 1], move_str);
  1024.         }
  1025.     }
  1026.     }
  1027.     
  1028.     if (ics_getting_history == H_GOT_REQ_HEADER) {
  1029.     /* This was an initial position from a move list, not
  1030.        the current position, so don't display it */
  1031.     return;
  1032.     }
  1033.  
  1034.     /* Update and display the clocks */
  1035.     timeRemaining[0][moveNum] = whiteTimeRemaining = white_time * 1000;
  1036.     timeRemaining[1][moveNum] = blackTimeRemaining = black_time * 1000;
  1037.     StartClocks();
  1038.  
  1039.     /* Display opponents and material strengths */
  1040.     sprintf(str, "%s (%d) vs. %s (%d)",
  1041.         ics_white, white_stren, ics_black, black_stren);
  1042.     DisplayTitle(str);
  1043.     
  1044.     /* Display the board */
  1045.     if (!pausing) {
  1046.     CommentPopDown();
  1047.     DrawPosition(FALSE, boards[currentMove]);
  1048.     DisplayMove(moveNum - 1);
  1049.     if (appData.ringBellAfterMoves && !ics_user_moved)
  1050.       RingBell();
  1051.     }
  1052. }
  1053.  
  1054. void ProcessICSInitScript(f)
  1055.      FILE *f;
  1056. {
  1057.     char buf[MSG_SIZ];
  1058.  
  1059.     while (fgets(buf, MSG_SIZ, f)) {
  1060.     SendToICS(buf);
  1061.     }
  1062.  
  1063.     fclose(f);
  1064. }
  1065.  
  1066. char PieceToChar(p)
  1067.      ChessSquare p;
  1068. {
  1069.     return pieceToChar[(int) p];
  1070. }
  1071.  
  1072. ChessSquare CharToPiece(c)
  1073.      int c;
  1074. {
  1075.     switch (c) {
  1076.       default:
  1077.       case '.':    return EmptySquare;
  1078.       case 'P':    return WhitePawn;
  1079.       case 'R':    return WhiteRook;
  1080.       case 'N':    return WhiteKnight;
  1081.       case 'B':    return WhiteBishop;
  1082.       case 'Q':    return WhiteQueen;
  1083.       case 'K':    return WhiteKing;
  1084.       case 'p':    return BlackPawn;
  1085.       case 'r':    return BlackRook;
  1086.       case 'n':    return BlackKnight;
  1087.       case 'b':    return BlackBishop;
  1088.       case 'q':    return BlackQueen;
  1089.       case 'k':    return BlackKing;
  1090.     }
  1091. }
  1092.  
  1093. ChessSquare PromoPiece(moveType)
  1094.      ChessMove moveType;
  1095. {
  1096.     switch (moveType) {
  1097.       default:
  1098.     return EmptySquare;
  1099.       case WhitePromotionQueen:
  1100.     return WhiteQueen;
  1101.       case BlackPromotionQueen:
  1102.     return BlackQueen;
  1103.       case WhitePromotionRook:
  1104.     return WhiteRook;
  1105.       case BlackPromotionRook:
  1106.     return BlackRook;
  1107.       case WhitePromotionBishop:
  1108.     return WhiteBishop;
  1109.       case BlackPromotionBishop:
  1110.     return BlackBishop;
  1111.       case WhitePromotionKnight:
  1112.     return WhiteKnight;
  1113.       case BlackPromotionKnight:
  1114.     return BlackKnight;
  1115.     }
  1116. }
  1117.  
  1118.  
  1119. /* Convert coordinates to normal algebraic notation.
  1120.    promoChar must be NULLCHAR or '.' if not a promotion.
  1121.    */
  1122. ChessMove CoordsToAlgebraic(fromX, fromY, toX, toY, promoChar,
  1123.                 currentBoardIndex, out)
  1124.      int fromX, fromY, toX, toY;
  1125.      int promoChar;
  1126.      int currentBoardIndex;
  1127.      char out[MOVE_LEN];
  1128. {
  1129.     ChessSquare piece;
  1130.     ChessMove ret;
  1131.     char *outp = out;
  1132.     int i;
  1133.     
  1134.     if (promoChar == '.') promoChar = NULLCHAR;
  1135.     piece = boards[currentBoardIndex][fromY][fromX];
  1136.     switch (piece) {
  1137.       case WhitePawn:
  1138.       case BlackPawn:
  1139.     /* Pawn move */
  1140.     *outp++ = fromX + 'a';
  1141.     if (fromX == toX) {
  1142.         /* Non-capture; use style "e5" or "e8Q" */
  1143.         *outp++ = toY + '1';
  1144.         *outp++ = ToUpper(promoChar);
  1145.         *outp = NULLCHAR;
  1146.     } else {
  1147.         /* Capture; use style "exd5" or "exd8Q" */
  1148.         *outp++ = 'x';
  1149.         *outp++ = toX + 'a';
  1150.         *outp++ = toY + '1';
  1151.         *outp++ = ToUpper(promoChar);
  1152.         *outp = NULLCHAR;
  1153.     }
  1154.     
  1155.     /* Test if okay by parsing; this notation should parse 
  1156.        unambiguously if the original move was legal.  More
  1157.        code would be needed if we wanted the style "ed" for
  1158.        captures, since that can be ambiguous.
  1159.        */
  1160.     ret = yylexstr(currentBoardIndex, out);
  1161.     break;
  1162.     
  1163.       case WhiteKing:
  1164.       case BlackKing:
  1165.     /* Test for castling or ICS wild castling */
  1166.     /* Use style "0-0" (zero-zero) */
  1167.     if (fromY == toY &&
  1168.         fromY == ((piece == WhiteKing) ? 0 : 7) &&
  1169.         ((fromX == 4 && (toX == 2 || toX == 6)) ||
  1170.          (fromX == 3 && (toX == 1 || toX == 5)))) {
  1171.         switch (toX) {
  1172.           case 1:
  1173.           case 6:
  1174.         strcpy(out, "0-0");
  1175.         break;
  1176.           case 2:
  1177.           case 5:
  1178.         strcpy(out, "0-0-0");
  1179.         break;
  1180.         }
  1181.         ret = yylexstr(currentBoardIndex, out);
  1182.         break;
  1183.     }
  1184.     /* else fall through */
  1185.     
  1186.       default:
  1187.     /* Piece move */
  1188.     /* First try style "Nf3" or "Nxf7" */
  1189.     *outp++ = ToUpper(PieceToChar(piece));
  1190.     
  1191.     /* Capture? */
  1192.     if(boards[currentBoardIndex][toY][toX] != EmptySquare)
  1193.       *outp++ = 'x';
  1194.     
  1195.     *outp++ = toX + 'a';
  1196.     *outp++ = toY + '1';
  1197.     *outp = NULLCHAR;
  1198.     
  1199.     /* Test if ambiguous */
  1200.     ret = yylexstr(currentBoardIndex, out);
  1201.     if (ret != AmbiguousMove) break;
  1202.     
  1203.     /* Try style "Ngf3" or "Nexf7" */
  1204.     for (i=4; i>=1; i--) out[i+1] = out[i];
  1205.     out[1] = fromX + 'a';
  1206.     
  1207.     /* Test if ambiguous */
  1208.     ret = yylexstr(currentBoardIndex, out);
  1209.     if (ret != AmbiguousMove) break;
  1210.     
  1211.     /* Try style "N1f3" */
  1212.     out[1] = fromY + '1';
  1213.     
  1214.     /* Test if ambiguous */
  1215.     ret = yylexstr(currentBoardIndex, out);
  1216.     if (ret != AmbiguousMove) break;
  1217.     
  1218.     /* Try style "Ng1f3" or "Ne5xf7" */
  1219.     /* Can be needed iff there are 3 or more pieces of the
  1220.        type being moved on the board, due to promotion */
  1221.     for (i=5; i>=2; i--) out[i+1] = out[i];
  1222.     out[1] = fromX + 'a';
  1223.     out[2] = fromY + '1';
  1224.     
  1225.     /* Test if okay */
  1226.     ret = yylexstr(currentBoardIndex, out);
  1227.     break; 
  1228.     
  1229.       case EmptySquare:
  1230.     /* Illegal move; use coordinate notation */
  1231.     *outp++ = fromX + 'a';
  1232.     *outp++ = fromY + '1';
  1233.     *outp++ = toX + 'a';
  1234.     *outp++ = toY + '1';
  1235.     *outp++ = ToUpper(promoChar);
  1236.     *outp = NULLCHAR;
  1237.     return BadMove;
  1238.     }
  1239.     
  1240.     switch (ret) {
  1241.       case NormalMove:
  1242.       case WhitePromotionKnight:
  1243.       case WhitePromotionBishop:
  1244.       case WhitePromotionRook:
  1245.       case WhitePromotionQueen:
  1246.       case BlackPromotionKnight:
  1247.       case BlackPromotionBishop:
  1248.       case BlackPromotionRook:
  1249.       case BlackPromotionQueen:
  1250.       case WhiteCapturesEnPassant:
  1251.       case BlackCapturesEnPassant:
  1252.       case WhiteKingSideCastle:
  1253.       case WhiteQueenSideCastle:
  1254.       case BlackKingSideCastle:
  1255.       case BlackQueenSideCastle:
  1256.       case WhiteKingSideCastleWild:
  1257.       case WhiteQueenSideCastleWild:
  1258.       case BlackKingSideCastleWild:
  1259.       case BlackQueenSideCastleWild:
  1260.     if (currentMoveString[0] != fromX + 'a' ||
  1261.         currentMoveString[1] != fromY + '1' ||
  1262.         currentMoveString[2] != toX + 'a' ||
  1263.         currentMoveString[3] != toY + '1' ||
  1264.         (promoChar != NULLCHAR &&
  1265.          currentMoveString[4] != ToLower(promoChar))) {
  1266.         /* Illegal move; use coordinate notation */
  1267.         outp = out;
  1268.         *outp++ = fromX + 'a';
  1269.         *outp++ = fromY + '1';
  1270.         *outp++ = toX + 'a';
  1271.         *outp++ = toY + '1';
  1272.         *outp++ = ToUpper(promoChar);
  1273.         *outp = NULLCHAR;
  1274.         return BadMove;
  1275.     }
  1276.     else
  1277.       return ret;
  1278.     
  1279.       default:
  1280.     /* Illegal move; use coordinate notation */
  1281.     outp = out;
  1282.     *outp++ = fromX + 'a';
  1283.     *outp++ = fromY + '1';
  1284.     *outp++ = toX + 'a';
  1285.     *outp++ = toY + '1';
  1286.     *outp++ = ToUpper(promoChar);
  1287.     *outp = NULLCHAR;
  1288.     return BadMove;
  1289.     }
  1290. }
  1291.  
  1292.  
  1293. void InitPosition(redraw)
  1294.      int redraw;
  1295. {
  1296.     currentMove = forwardMostMove = backwardMostMove = 0;
  1297.     CopyBoard(boards[0], initialPosition);
  1298.     if (redraw)
  1299.       DrawPosition(FALSE, boards[currentMove]);
  1300. }
  1301.  
  1302. void CopyBoard(to, from)
  1303.      Board to, from;
  1304. {
  1305.     int i, j;
  1306.     
  1307.     for (i = 0; i < BOARD_SIZE; i++)
  1308.       for (j = 0; j < BOARD_SIZE; j++)
  1309.     to[i][j] = from[i][j];
  1310. }
  1311.  
  1312. Boolean CompareBoards(board1, board2)
  1313.      Board board1, board2;
  1314. {
  1315.     int i, j;
  1316.     
  1317.     for (i = 0; i < BOARD_SIZE; i++)
  1318.       for (j = 0; j < BOARD_SIZE; j++) {
  1319.       if (board1[i][j] != board2[i][j])
  1320.         return FALSE;
  1321.     }
  1322.     return TRUE;
  1323. }
  1324.  
  1325. void SendCurrentBoard(pr)
  1326.      ProcRef pr;
  1327. {
  1328.     SendBoard(pr, boards[currentMove]);
  1329. }
  1330.  
  1331. void SendBoard(pr, board)
  1332.      ProcRef pr;
  1333.      Board board;
  1334. {
  1335.     char message[MSG_SIZ];
  1336.     ChessSquare *bp;
  1337.     int i, j;
  1338.     
  1339.     SendToProgram("edit\n", pr);
  1340.     SendToProgram("#\n", pr);
  1341.     for (i = BOARD_SIZE - 1; i >= 0; i--) {
  1342.     bp = &board[i][0];
  1343.     for (j = 0; j < BOARD_SIZE; j++, bp++) {
  1344.         if ((int) *bp < (int) BlackPawn) {
  1345.         sprintf(message, "%c%c%c\n", PieceToChar(*bp), 
  1346.             'a' + j, '1' + i);
  1347.         SendToProgram(message, pr);
  1348.         }
  1349.     }
  1350.     }
  1351.     
  1352.     SendToProgram("c\n", pr);
  1353.     for (i = BOARD_SIZE - 1; i >= 0; i--) {
  1354.     bp = &board[i][0];
  1355.     for (j = 0; j < BOARD_SIZE; j++, bp++) {
  1356.         if (((int) *bp != (int) EmptySquare)
  1357.         && ((int) *bp >= (int) BlackPawn)) {
  1358.         sprintf(message, "%c%c%c\n", ToUpper(PieceToChar(*bp)),
  1359.             'a' + j, '1' + i);
  1360.         SendToProgram(message, pr);
  1361.         }
  1362.     }
  1363.     }
  1364.     
  1365.     SendToProgram(".\n", pr);
  1366. }
  1367.  
  1368.  
  1369. int IsPromotion(fromX, fromY, toX, toY)
  1370.      int fromX, fromY, toX, toY;
  1371. {
  1372.     return gameMode != EditPosition &&
  1373.       fromX >=0 && fromY >= 0 && toX >= 0 && toY >= 0 &&
  1374.     ((boards[currentMove][fromY][fromX] == WhitePawn && toY == 7) ||
  1375.      (boards[currentMove][fromY][fromX] == BlackPawn && toY == 0));
  1376. }
  1377.  
  1378.  
  1379. int OKToStartUserMove(x, y)
  1380.      int x, y;
  1381. {
  1382.     ChessSquare from_piece;
  1383.     int white_piece;
  1384.  
  1385.     if (matchMode) return FALSE;
  1386.  
  1387.     if (x >= 0 && y >= 0)
  1388.       from_piece = boards[currentMove][y][x];
  1389.     else
  1390.       from_piece = EmptySquare;
  1391.  
  1392.     if (gameMode == EditPosition) return TRUE;
  1393.     if (from_piece == EmptySquare) return FALSE;
  1394.  
  1395.     white_piece = (int)from_piece >= (int)WhitePawn &&
  1396.                   (int)from_piece <= (int)WhiteKing;
  1397.  
  1398.     switch (gameMode) {
  1399.       case EndOfGame:
  1400.       case PlayFromGameFile:
  1401.       case TwoMachinesPlay:
  1402.     return FALSE;
  1403.  
  1404.       case IcsObserving:
  1405.       case IcsIdle:
  1406.     return FALSE;
  1407.  
  1408.       case MachinePlaysWhite:
  1409.       case IcsPlayingBlack:
  1410.     if (white_piece) {
  1411.         DisplayError("You are playing Black", 0);
  1412.         return FALSE;
  1413.     }
  1414.     break;
  1415.  
  1416.       case IcsPlayingWhite:
  1417.       case MachinePlaysBlack:
  1418.     if (!white_piece) {
  1419.         DisplayError("You are playing White", 0);
  1420.         return FALSE;
  1421.     }
  1422.     break;
  1423.  
  1424.       case ForceMoves:
  1425.     /*!!Prompt for confirmation if discarding moves?*/
  1426.     forwardMostMove = currentMove;
  1427.     break;
  1428.  
  1429.       case BeginningOfGame:
  1430.     if (appData.icsActive) return FALSE;
  1431.     if (!appData.noChessProgram) {
  1432.         if (!white_piece) {
  1433.         DisplayError("You are playing White", 0);
  1434.         return FALSE;
  1435.         }
  1436.     }
  1437.     break;
  1438.  
  1439.       default:
  1440.     break;
  1441.     }
  1442.     if (currentMove != forwardMostMove) {
  1443.     DisplayError("Displayed position is not current", 0);
  1444.     return FALSE;
  1445.     }
  1446.     return TRUE;
  1447. }
  1448.  
  1449. void UserMoveEvent(fromX, fromY, toX, toY, promoChar)
  1450.      int fromX, fromY, toX, toY;
  1451.      int promoChar;
  1452. {
  1453.     ChessMove moveType;
  1454.     char user_move[MSG_SIZ];
  1455.     
  1456.     if (fromX < 0 || fromY < 0) return;
  1457.     if ((fromX == toX) && (fromY == toY)) {
  1458.     return;
  1459.     }
  1460.     
  1461.     if (toX < 0 || toY < 0) {
  1462.     if (gameMode == EditPosition && (toX == -2 || toY == -2)) {
  1463.         boards[0][fromY][fromX] = EmptySquare;
  1464.         DrawPosition(FALSE, boards[currentMove]);
  1465.     }
  1466.     return;
  1467.     }
  1468.     
  1469.     if (gameMode == EditPosition) {
  1470.     boards[0][toY][toX] = boards[0][fromY][fromX];
  1471.     boards[0][fromY][fromX] = EmptySquare;
  1472.     DrawPosition(FALSE, boards[currentMove]);
  1473.     return;
  1474.     }
  1475.     
  1476.     /* Check if the user is playing in turn.  This is complicated because we
  1477.        let the user "pick up" a piece before it is his turn.  So the piece he
  1478.        tried to pick up may have been captured by the time he puts it down!
  1479.        Therefore we use the color the user is supposed to be playing in this
  1480.        test, not the color of the piece that is currently on the starting
  1481.        square---except in ForceMoves mode, where the user is playing both
  1482.        sides; fortunately there the capture race can't happen. 
  1483.     */
  1484.     if (gameMode == MachinePlaysWhite || gameMode == IcsPlayingBlack ||
  1485.     ((gameMode == ForceMoves || gameMode == BeginningOfGame) && 
  1486.      (int) boards[currentMove][fromY][fromX] >= (int) BlackPawn &&
  1487.      (int) boards[currentMove][fromY][fromX] <= (int) BlackKing)) {
  1488.     /* User is moving for Black */
  1489.     if (WhiteOnMove(currentMove)) {
  1490.         DisplayError("It is White's turn", 0);
  1491.         return;
  1492.     }
  1493.     } else {
  1494.     /* User is moving for White */
  1495.     if (!WhiteOnMove(currentMove)) {
  1496.         DisplayError("It is Black's turn", 0);
  1497.         return;
  1498.     }
  1499.     }
  1500.  
  1501.     moveType = LegalityTest(WhiteOnMove(currentMove),
  1502.                  boards[currentMove], fromY, fromX,
  1503.                  toY, toX, promoChar);
  1504.  
  1505.     if (moveType == BadMove) {
  1506.     DisplayError("Illegal move", 0);
  1507.     return;
  1508.     }
  1509.  
  1510.     /* A user move restarts a paused game*/
  1511.     if (pausing)
  1512.       PauseEvent();
  1513.     
  1514.     MakeMove(&moveType, fromX, fromY, toX, toY);
  1515.  
  1516.     if (appData.icsActive) {
  1517.     if (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack) {
  1518.         sprintf(user_move, "%c%c%c%c\n",
  1519.             'a' + fromX, '1' + fromY, 'a' + toX, '1' + toY);
  1520.         switch (moveType) {
  1521.           default:
  1522.         DisplayError("Internal error; bad moveType", 0);
  1523.         break;
  1524.           case WhiteKingSideCastle:
  1525.           case BlackKingSideCastle:
  1526.           case WhiteQueenSideCastleWild:
  1527.           case BlackQueenSideCastleWild:
  1528.         sprintf(user_move, "o-o\n");
  1529.         break;
  1530.           case WhiteQueenSideCastle:
  1531.           case BlackQueenSideCastle:
  1532.           case WhiteKingSideCastleWild:
  1533.           case BlackKingSideCastleWild:
  1534.         sprintf(user_move, "o-o-o\n");
  1535.         break;
  1536.           case WhitePromotionQueen:
  1537.           case BlackPromotionQueen:
  1538.         SendToICS("promote queen\n");
  1539.         break;
  1540.           case WhitePromotionRook:
  1541.           case BlackPromotionRook:
  1542.         SendToICS("promote rook\n");
  1543.         break;
  1544.           case WhitePromotionBishop:
  1545.           case BlackPromotionBishop:
  1546.         SendToICS("promote bishop\n");
  1547.         break;
  1548.           case WhitePromotionKnight:
  1549.           case BlackPromotionKnight:
  1550.         SendToICS("promote knight\n");
  1551.         break;
  1552.           case NormalMove:
  1553.           case WhiteCapturesEnPassant:
  1554.           case BlackCapturesEnPassant:
  1555.         break;
  1556.         }
  1557.         SendToICS(user_move);
  1558.         ics_user_moved = 1;
  1559.     }
  1560.     } else {
  1561.     promoChar = ToLower(PieceToChar(PromoPiece(moveType)));
  1562.     if (promoChar == '.')
  1563.       sprintf(user_move, "%c%c%c%c\n",
  1564.           'a' + fromX, '1' + fromY, 'a' + toX, '1' + toY);
  1565.     else
  1566.       sprintf(user_move, "%c%c%c%c%c\n",
  1567.           'a' + fromX, '1' + fromY, 'a' + toX, '1' + toY,
  1568.           promoChar);
  1569.     
  1570.     Attention(firstProgramPR);
  1571.     if (firstSendTime)
  1572.       SendTimeRemaining(firstProgramPR);
  1573.     SendToProgram(user_move, firstProgramPR);
  1574.     }
  1575.     
  1576.     strcpy(moveList[currentMove - 1], user_move);
  1577.     
  1578.     switch (gameMode) {
  1579.       case PlayFromGameFile:
  1580.     ForceMovesEvent();
  1581.     break;
  1582.       case BeginningOfGame:
  1583.     if (appData.noChessProgram)
  1584.       lastGameMode = gameMode = ForceMoves;
  1585.     else
  1586.       lastGameMode = gameMode = MachinePlaysBlack;
  1587.     ModeHighlight();
  1588.     break;
  1589.       case ForceMoves:
  1590.       case MachinePlaysBlack:
  1591.       case MachinePlaysWhite:
  1592.       default:
  1593.     break;
  1594.     }
  1595. }
  1596.  
  1597. /* Parser for moves from gnuchess or ICS */
  1598. Boolean ParseMachineMove(machineMove, moveNum,
  1599.              moveType, fromX, fromY, toX, toY, promoChar)
  1600.      char *machineMove;
  1601.      int moveNum;
  1602.      ChessMove *moveType;
  1603.      int *fromX, *fromY, *toX, *toY;
  1604.      char *promoChar;
  1605. {       
  1606.     char buf[MSG_SIZ];
  1607.  
  1608.     *moveType = yylexstr(moveNum, machineMove);
  1609.     switch (*moveType) {
  1610.       case WhitePromotionQueen:
  1611.       case BlackPromotionQueen:
  1612.       case WhitePromotionRook:
  1613.       case BlackPromotionRook:
  1614.       case WhitePromotionBishop:
  1615.       case BlackPromotionBishop:
  1616.       case WhitePromotionKnight:
  1617.       case BlackPromotionKnight:
  1618.       case NormalMove:
  1619.       case WhiteCapturesEnPassant:
  1620.       case BlackCapturesEnPassant:
  1621.       case WhiteKingSideCastle:
  1622.       case WhiteQueenSideCastle:
  1623.       case BlackKingSideCastle:
  1624.       case BlackQueenSideCastle:
  1625.       case WhiteKingSideCastleWild:
  1626.       case WhiteQueenSideCastleWild:
  1627.       case BlackKingSideCastleWild:
  1628.       case BlackQueenSideCastleWild:
  1629.     *fromX = currentMoveString[0] - 'a';
  1630.     *fromY = currentMoveString[1] - '1';
  1631.     *toX = currentMoveString[2] - 'a';
  1632.     *toY = currentMoveString[3] - '1';
  1633.     *promoChar = currentMoveString[4];
  1634.     return TRUE;
  1635.  
  1636.       case BadMove:
  1637.       case AmbiguousMove:
  1638.       case (ChessMove) 0:    /* end of file */
  1639.       case ElapsedTime:
  1640.       case Comment:
  1641.       case WhiteWins:
  1642.       case BlackWins:
  1643.       case GameIsDrawn:
  1644.       default:
  1645.     /* bug? */
  1646.     sprintf(buf, "Bad move in chess program output: %s",
  1647.         machineMove);
  1648.     DisplayError(buf, 0);
  1649.     *fromX = *fromY = *toX = *toY = 0;
  1650.     return FALSE;
  1651.     }
  1652. }
  1653.  
  1654. void HandleMachineMove(message, isr)
  1655.      char *message;
  1656.      InputSourceRef isr;
  1657. {
  1658.     char machineMove[MSG_SIZ], buf1[MSG_SIZ], buf2[MSG_SIZ];
  1659.     int fromX, fromY, toX, toY;
  1660.     ChessMove moveType;
  1661.     char promoChar;
  1662.     
  1663.     maybeThinking = FALSE;
  1664.     
  1665.     if (strncmp(message, "warning:", 8) == 0) {
  1666.     DisplayError(message, 0);
  1667.     return;
  1668.     }
  1669.     
  1670.     /*
  1671.      * If chess program startup fails, exit with an error message.
  1672.      * Attempts to recover here are futile.
  1673.      */
  1674.     if ((StrStr(message, "unknown host") != NULL)
  1675.     || (StrStr(message, "No remote directory") != NULL)
  1676.     || (StrStr(message, "not found") != NULL)
  1677.     || (StrStr(message, "No such file") != NULL)
  1678.     || (StrStr(message, "Permission denied") != NULL)) {
  1679.     sprintf(buf1,
  1680.         "Failed to start chess program %s on %s: %s\n",
  1681.         isr == firstProgramISR ? appData.firstChessProgram
  1682.         : appData.secondChessProgram,
  1683.         isr == firstProgramISR ? appData.firstHost
  1684.         : appData.secondHost,
  1685.         message);
  1686.     DisplayFatalError(buf1, 0);
  1687.     ExitEvent(1);
  1688.     }
  1689.     
  1690.     if (strncmp(message, "time", 4) == 0) {
  1691.     if (StrStr(message, "CHESS")) {
  1692.         /* Program has a broken "time" command that
  1693.            outputs a string not ending in newline.
  1694.            Don't use it. */
  1695.         if (isr == firstProgramISR) firstSendTime = 0;
  1696.         if (isr == secondProgramISR) secondSendTime = 0;
  1697.     } else {
  1698.         if (isr == firstProgramISR) firstSendTime = 1;
  1699.         if (isr == secondProgramISR) secondSendTime = 1;
  1700.     }
  1701.     }
  1702.     
  1703.     /*
  1704.      * If the move is illegal, cancel it and redraw the board.
  1705.      */
  1706.     if (strncmp(message, "Illegal move", 12) == 0) {
  1707.     
  1708.     if (isr == firstProgramISR && firstSendTime == 2) {
  1709.         /* First program doesn't have the "time" command */
  1710.         firstSendTime = 0;
  1711.         return;
  1712.     } else if (isr == secondProgramISR && secondSendTime == 2) {
  1713.         /* Second program doesn't have the "time" command */
  1714.         secondSendTime = 0;
  1715.         return;
  1716.     }
  1717.     if (forwardMostMove <= backwardMostMove) return;
  1718.     if (pausing) PauseEvent();
  1719.     if (gameMode == PlayFromGameFile) {
  1720.         /* Stop reading this game file */
  1721.         gameMode = ForceMoves;
  1722.         ModeHighlight();
  1723.     }
  1724.     currentMove = --forwardMostMove;
  1725.     SwitchClocks();
  1726.     sprintf(buf1, "Illegal move: %s", parseList[currentMove]);
  1727.     DisplayError(buf1, 0);
  1728.     
  1729.     DrawPosition(FALSE, boards[currentMove]);
  1730.     return;
  1731.     }
  1732.     
  1733.     if (strncmp(message, "Hint:", 5) == 0) {
  1734.     sscanf(message, "Hint: %s", machineMove);
  1735.     if (ParseMachineMove(machineMove, forwardMostMove, &moveType,
  1736.                  &fromX, &fromY, &toX, &toY, &promoChar)) {
  1737.         moveType = CoordsToAlgebraic(fromX, fromY, toX, toY, promoChar,
  1738.                      forwardMostMove, buf1);
  1739.         sprintf(buf2, "Hint: %s", buf1);
  1740.         DisplayMessage(buf2);
  1741.     } else {
  1742.         /* Hint move was illegal!? */
  1743.         DisplayMessage(message);
  1744.     }
  1745.     return;
  1746.     }
  1747.     
  1748.     /*
  1749.      * win, lose or draw
  1750.      */
  1751.     if (strncmp(message, "White", 5) == 0) {
  1752.     ShutdownChessPrograms("White mates");
  1753.     return;
  1754.     } else if (strncmp(message, "Black", 5) == 0) {
  1755.     ShutdownChessPrograms("Black mates");
  1756.     return;
  1757.     } else if (strncmp(message, "opponent mates!", 15) == 0) {
  1758.     switch (gameMode) {
  1759.       case MachinePlaysBlack:
  1760.         ShutdownChessPrograms("White mates");
  1761.         break;
  1762.       case MachinePlaysWhite:
  1763.         ShutdownChessPrograms("Black mates");
  1764.         break;
  1765.       case TwoMachinesPlay:
  1766.         ShutdownChessPrograms(isr == firstProgramISR ?
  1767.                   "White mates" : "Black mates");
  1768.         break;
  1769.       default:
  1770.         /* can't happen */
  1771.         break;
  1772.     }
  1773.     return;
  1774.     } else if (strncmp(message, "computer mates!", 15) == 0) {
  1775.     switch (gameMode) {
  1776.       case MachinePlaysBlack:
  1777.         ShutdownChessPrograms("Black mates");
  1778.         break;
  1779.       case MachinePlaysWhite:
  1780.         ShutdownChessPrograms("White mates");
  1781.         break;
  1782.       case TwoMachinesPlay:
  1783.         ShutdownChessPrograms(isr == firstProgramISR ?
  1784.                   "Black mates" : "White mates");
  1785.         break;
  1786.       default:
  1787.         /* can't happen */
  1788.         break;
  1789.     }
  1790.     return;
  1791.     } else if (strncmp(message, "Draw", 4) == 0) {
  1792.     ShutdownChessPrograms("Draw");
  1793.     return;
  1794.     }
  1795.     
  1796.     /*
  1797.      * normal machine reply move
  1798.      */
  1799.     maybeThinking = TRUE;
  1800.     if (StrStr(message, "...") != NULL) {
  1801.     sscanf(message, "%s %s %s", buf1, buf2, machineMove);
  1802.     if (machineMove[0] == NULLCHAR)
  1803.       return;
  1804.     } else
  1805.       return;        /* ignore noise */
  1806.     
  1807.     strcat(machineMove, "\n");
  1808.     strcpy(moveList[forwardMostMove], machineMove);
  1809.     
  1810.     if (!ParseMachineMove(machineMove, forwardMostMove, &moveType,
  1811.               &fromX, &fromY, &toX, &toY, &promoChar)) {
  1812.     /* Machine move was illegal!?  What to do? */
  1813.     DisplayError("Ignoring illegal move from machine", 0);
  1814.     return;
  1815.     }
  1816.     
  1817.     if (!pausing)
  1818.       currentMove = forwardMostMove;  /*display latest move*/
  1819.     
  1820.     MakeMove(&moveType, fromX, fromY, toX, toY);
  1821.     
  1822.     if (!pausing && appData.ringBellAfterMoves)
  1823.       RingBell();
  1824.     
  1825.     if (gameMode == TwoMachinesPlay) {
  1826.     if (WhiteOnMove(forwardMostMove)) {
  1827.         Attention(secondProgramPR);
  1828.         if (secondSendTime) 
  1829.           SendTimeRemaining(secondProgramPR);
  1830.         SendToProgram(machineMove, secondProgramPR);
  1831.         if (firstMove) {
  1832.         firstMove = FALSE;
  1833.         SendToProgram(appData.whiteString,
  1834.                   secondProgramPR);
  1835.         }
  1836.     } else {
  1837.         Attention(firstProgramPR);
  1838.         if (firstSendTime)
  1839.           SendTimeRemaining(firstProgramPR);
  1840.         SendToProgram(machineMove, firstProgramPR);
  1841.         if (firstMove) {
  1842.         firstMove = FALSE;
  1843.         SendToProgram(appData.blackString,
  1844.                   firstProgramPR);
  1845.         }
  1846.     }
  1847.     }
  1848. }
  1849.  
  1850.  
  1851. /* Parse a game score from the character string "game", and
  1852.    record it as the history of the current game.  The game
  1853.    score is NOT assumed to start from the standard position. 
  1854.    The display is not updated in any way.
  1855.    */
  1856. void ParseGameHistory(game)
  1857.      char *game;
  1858. {
  1859.     ChessMove moveType;
  1860.     int fromX, fromY, toX, toY, boardIndex;
  1861.     char promoChar;
  1862.     char *p;
  1863.     char buf[MSG_SIZ];
  1864.  
  1865.     if (appData.debugMode)
  1866.       fprintf(debugFP, "Parsing game history: %s\n", game);
  1867.  
  1868.     /* Parse out names of players */
  1869.     while (*game == ' ') game++;
  1870.     p = ics_white;
  1871.     while (*game != ' ') *p++ = *game++;
  1872.     *p = NULLCHAR;
  1873.     while (*game == ' ') game++;
  1874.     p = ics_black;
  1875.     while (*game != ' ' && *game != '\n') *p++ = *game++;
  1876.     *p = NULLCHAR;
  1877.  
  1878.     /* Parse moves */
  1879.     boardIndex = 0;
  1880.     yynewstr(game);
  1881.     for (;;) {
  1882.     yyboardindex = boardIndex;
  1883.     moveType = (ChessMove) yylex();
  1884.     switch (moveType) {
  1885.       case WhitePromotionQueen:
  1886.       case BlackPromotionQueen:
  1887.       case WhitePromotionRook:
  1888.       case BlackPromotionRook:
  1889.       case WhitePromotionBishop:
  1890.       case BlackPromotionBishop:
  1891.       case WhitePromotionKnight:
  1892.       case BlackPromotionKnight:
  1893.       case NormalMove:
  1894.       case WhiteCapturesEnPassant:
  1895.       case BlackCapturesEnPassant:
  1896.       case WhiteKingSideCastle:
  1897.       case WhiteQueenSideCastle:
  1898.       case BlackKingSideCastle:
  1899.       case BlackQueenSideCastle:
  1900.       case WhiteKingSideCastleWild:
  1901.       case WhiteQueenSideCastleWild:
  1902.       case BlackKingSideCastleWild:
  1903.       case BlackQueenSideCastleWild:
  1904.         fromX = currentMoveString[0] - 'a';
  1905.         fromY = currentMoveString[1] - '1';
  1906.         toX = currentMoveString[2] - 'a';
  1907.         toY = currentMoveString[3] - '1';
  1908.         promoChar = currentMoveString[4];
  1909.         break;
  1910.       case BadMove:
  1911.       case AmbiguousMove:
  1912.         /* bug? */
  1913.         sprintf(buf, "Bad move in ICS output: %s", yytext);
  1914.         DisplayError(buf, 0);
  1915.         /* fall thru */
  1916.       case (ChessMove) 0:    /* end of file */
  1917.         if (boardIndex < backwardMostMove) {
  1918.         /* Oops, gap.  How did that happen? */
  1919.         return;
  1920.         }
  1921.         backwardMostMove = 0;
  1922.         if (boardIndex > forwardMostMove) {
  1923.         forwardMostMove = boardIndex;
  1924.         }
  1925.         return;
  1926.       case ElapsedTime:
  1927.         if (boardIndex > 0) {
  1928.         strcat(parseList[boardIndex-1], " ");
  1929.         strcat(parseList[boardIndex-1], yytext);
  1930.         }
  1931.         continue;
  1932.       case Comment:
  1933.       default:
  1934.         /* ignore */
  1935.         continue;
  1936.       case WhiteWins:
  1937.       case BlackWins:
  1938.       case GameIsDrawn:
  1939.         strncpy(endMessage, yytext, MOVE_LEN * 4);
  1940.         endMessage[MOVE_LEN * 4 - 1] = NULLCHAR;
  1941.         continue;
  1942.     }
  1943.     (void) CoordsToAlgebraic(fromX, fromY, toX, toY, promoChar,
  1944.                  boardIndex, parseList[boardIndex]);
  1945.     CopyBoard(boards[boardIndex + 1], boards[boardIndex]);
  1946.     boardIndex++;
  1947.     ApplyMove(&moveType, fromX, fromY, toX, toY,
  1948.           boards[boardIndex]);
  1949.     }
  1950. }
  1951.  
  1952. void LoadGameLoop()
  1953. {
  1954.     for (;;) {
  1955.     if (!LoadGameOneMove())
  1956.       return;
  1957.     if (matchMode || appData.timeDelay == 0)
  1958.       continue;
  1959.     if (appData.timeDelay < 0)
  1960.       return;
  1961.         StartLoadGameTimer((long)(1000.0 * appData.timeDelay));
  1962.     break;
  1963.     }
  1964. }
  1965.  
  1966. int LoadGameOneMove()
  1967. {
  1968.     int fromX, fromY, toX, toY, done;
  1969.     ChessMove moveType;
  1970.     char move[MSG_SIZ];
  1971.     
  1972.     if (gameFileFP == NULL)
  1973.       return FALSE;
  1974.     
  1975.     if (gameMode != PlayFromGameFile) {
  1976.     gameFileFP = NULL;
  1977.     return FALSE;
  1978.     }
  1979.     
  1980.     yyboardindex = forwardMostMove;
  1981.     moveType = (ChessMove) yylex();
  1982.     
  1983.     done = FALSE;
  1984.     switch (moveType) {
  1985.       case Comment:
  1986.     if (appData.debugMode) 
  1987.       fprintf(debugFP, "Parsed Comment: %s\n", yytext);
  1988.     if (!matchMode && (pausing || appData.timeDelay != 0)) {
  1989.         CommentPopUp(yytext);
  1990.     }
  1991.     AppendComment(currentMove, yytext);
  1992.     return TRUE;
  1993.  
  1994.       case WhiteCapturesEnPassant:
  1995.       case BlackCapturesEnPassant:
  1996.       case WhitePromotionQueen:
  1997.       case BlackPromotionQueen:
  1998.       case WhitePromotionRook:
  1999.       case BlackPromotionRook:
  2000.       case WhitePromotionBishop:
  2001.       case BlackPromotionBishop:
  2002.       case WhitePromotionKnight:
  2003.       case BlackPromotionKnight:
  2004.       case NormalMove:
  2005.       case WhiteKingSideCastle:
  2006.       case WhiteQueenSideCastle:
  2007.       case BlackKingSideCastle:
  2008.       case BlackQueenSideCastle:
  2009.       case WhiteKingSideCastleWild:
  2010.       case WhiteQueenSideCastleWild:
  2011.       case BlackKingSideCastleWild:
  2012.       case BlackQueenSideCastleWild:
  2013.     if (appData.debugMode)
  2014.       fprintf(debugFP, "Parsed %s into %s\n", yytext, currentMoveString);
  2015.     fromX = currentMoveString[0] - 'a';
  2016.     fromY = currentMoveString[1] - '1';
  2017.     toX = currentMoveString[2] - 'a';
  2018.     toY = currentMoveString[3] - '1';
  2019.     break;
  2020.  
  2021.       case (ChessMove) 0:  /* end of file */
  2022.     if (appData.debugMode)
  2023.       fprintf(debugFP, "Parser hit end of file\n");
  2024.     DisplayMessage("End of game file");
  2025.     done = TRUE;
  2026.     break;
  2027.  
  2028.       case WhiteWins:
  2029.       case BlackWins:
  2030.       case GameIsDrawn:
  2031.     if (appData.debugMode)
  2032.       fprintf(debugFP, "Parsed game end: %s\n", yytext);
  2033.     if (appData.matchMode || (appData.timeDelay == 0 && !pausing)) {
  2034.         DrawPosition(FALSE, boards[currentMove]);
  2035.         if (!appData.matchMode && commentList[currentMove] != NULL)
  2036.           CommentPopUp(commentList[currentMove]);
  2037.     }
  2038.     GameEnds(yytext);
  2039.     return FALSE;
  2040.  
  2041.       case XBoardGame:
  2042.       case GNUChessGame:
  2043.     /* Reached start of next game in file */
  2044.     if (appData.debugMode)
  2045.       fprintf(debugFP, "Parsed start of next game: %s\n", yytext);
  2046.     DisplayMessage("End of game");
  2047.     done = TRUE;
  2048.     break;
  2049.  
  2050.       case PositionDiagram:
  2051.     /* should not happen; ignore */
  2052.       case MoveNumberOne:
  2053.     /* ignore; we see too many bogus move numbers,
  2054.        especially in GNUChess game files */
  2055.       case ElapsedTime:
  2056.     /* ignore */
  2057.     if (appData.debugMode)
  2058.       fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
  2059.           yytext, (int) moveType);
  2060.     return LoadGameOneMove(); /* tail recursion */
  2061.  
  2062.       default:
  2063.       case BadMove:
  2064.     if (appData.debugMode)
  2065.       fprintf(debugFP, "Parsed BadMove: %s\n", yytext);
  2066.     sprintf(move, "Bad move: %d. %s%s",
  2067.         (forwardMostMove / 2) + 1,
  2068.         WhiteOnMove(forwardMostMove) ? "" : "... ", yytext);
  2069.     DisplayError(move, 0);
  2070.     done = TRUE;
  2071.     break;
  2072.  
  2073.       case AmbiguousMove:
  2074.     if (appData.debugMode)
  2075.       fprintf(debugFP, "Parsed AmbiguousMove: %s\n", yytext);
  2076.     sprintf(move, "Ambiguous move: %d. %s%s",
  2077.         (forwardMostMove / 2) + 1,
  2078.         WhiteOnMove(forwardMostMove) ? "" : "... ", yytext);
  2079.     DisplayError(move, 0);
  2080.     done = TRUE;
  2081.     break;
  2082.     }
  2083.     
  2084.     if (done) {
  2085.     if (appData.matchMode || (appData.timeDelay == 0 && !pausing)) {
  2086.         DrawPosition(FALSE, boards[currentMove]);
  2087.         if (!appData.matchMode && commentList[currentMove] != NULL)
  2088.           CommentPopUp(commentList[currentMove]);
  2089.     }
  2090.     lastGameMode = gameMode;
  2091.     gameMode = ForceMoves;
  2092.     ModeHighlight();
  2093.         (void) StopLoadGameTimer();
  2094.     gameFileFP = NULL;
  2095.     return FALSE;
  2096.     } else {
  2097.     strcat(currentMoveString, "\n");
  2098.     strcpy(moveList[forwardMostMove], currentMoveString);
  2099.     SendToProgram(currentMoveString, firstProgramPR);
  2100.     
  2101.     MakeMove(&moveType, fromX, fromY, toX, toY);
  2102.     
  2103.     return TRUE;
  2104.     }
  2105. }
  2106.  
  2107. /* Apply a move to the given board.  Oddity: moveType is ignored on
  2108.    input unless the move is seen to be a pawn promotion, in which case
  2109.    moveType tells us what to promote to.
  2110. */
  2111. void ApplyMove(moveType, fromX, fromY, toX, toY, board)
  2112.      ChessMove *moveType;
  2113.      int fromX, fromY, toX, toY;
  2114.      Board board;
  2115. {
  2116.     if (fromY == 0 && fromX == 4
  2117.     && board[fromY][fromX] == WhiteKing
  2118.     && toY == 0 && toX == 6) {
  2119.     *moveType = WhiteKingSideCastle;
  2120.      board[fromY][fromX] = EmptySquare;
  2121.      board[toY][toX] = WhiteKing;
  2122.      board[fromY][7] = EmptySquare;
  2123.      board[toY][5] = WhiteRook;
  2124.     } else if (fromY == 0 && fromX == 4
  2125.            && board[fromY][fromX] == WhiteKing
  2126.            && toY == 0 && toX == 2) {
  2127.     *moveType = WhiteQueenSideCastle;
  2128.      board[fromY][fromX] = EmptySquare;
  2129.      board[toY][toX] = WhiteKing;
  2130.      board[fromY][0] = EmptySquare;
  2131.      board[toY][3] = WhiteRook;
  2132.     } else if (fromY == 0 && fromX == 3
  2133.      && board[fromY][fromX] == WhiteKing
  2134.      && toY == 0 && toX == 5) {
  2135.      *moveType = WhiteKingSideCastleWild;
  2136.      board[fromY][fromX] = EmptySquare;
  2137.      board[toY][toX] = WhiteKing;
  2138.      board[fromY][7] = EmptySquare;
  2139.      board[toY][4] = WhiteRook;
  2140.     } else if (fromY == 0 && fromX == 3
  2141.             && board[fromY][fromX] == WhiteKing
  2142.             && toY == 0 && toX == 1) {
  2143.      *moveType = WhiteQueenSideCastleWild;
  2144.      board[fromY][fromX] = EmptySquare;
  2145.      board[toY][toX] = WhiteKing;
  2146.      board[fromY][0] = EmptySquare;
  2147.      board[toY][2] = WhiteRook;
  2148.     } else if (fromY == 6
  2149.            && board[fromY][fromX] == WhitePawn
  2150.            && toY == 7) {
  2151.     /* white pawn promotion */
  2152.     board[7][toX] = PromoPiece(*moveType);
  2153.     if (board[7][toX] == EmptySquare) {
  2154.         board[7][toX] = WhiteQueen;
  2155.         *moveType = WhitePromotionQueen;
  2156.     }
  2157.     board[6][fromX] = EmptySquare;
  2158.     } else if ((fromY == 4)
  2159.            && (toX != fromX)
  2160.            && (board[fromY][fromX] == WhitePawn)
  2161.            && (board[toY][toX] == EmptySquare)) {
  2162.     *moveType = WhiteCapturesEnPassant;
  2163.     board[fromY][fromX] = EmptySquare;
  2164.     board[toY][toX] = WhitePawn;
  2165.     board[toY - 1][toX] = EmptySquare;
  2166.    } else if (fromY == 7 && fromX == 4
  2167.            && board[fromY][fromX] == BlackKing
  2168.            && toY == 7 && toX == 6) {
  2169.     *moveType = BlackKingSideCastle;
  2170.      board[fromY][fromX] = EmptySquare;
  2171.      board[toY][toX] = BlackKing;
  2172.      board[fromY][7] = EmptySquare;
  2173.      board[toY][5] = BlackRook;
  2174.    } else if (fromY == 7 && fromX == 4
  2175.            && board[fromY][fromX] == BlackKing
  2176.            && toY == 7 && toX == 2) {
  2177.     *moveType = BlackQueenSideCastle;
  2178.      board[fromY][fromX] = EmptySquare;
  2179.      board[toY][toX] = BlackKing;
  2180.      board[fromY][0] = EmptySquare;
  2181.      board[toY][3] = BlackRook;
  2182.     } else if (fromY == 7 && fromX == 3
  2183.             && board[fromY][fromX] == BlackKing
  2184.             && toY == 7 && toX == 5) {
  2185.      *moveType = BlackKingSideCastleWild;
  2186.      board[fromY][fromX] = EmptySquare;
  2187.      board[toY][toX] = BlackKing;
  2188.      board[fromY][7] = EmptySquare;
  2189.      board[toY][4] = BlackRook;
  2190.     } else if (fromY == 7 && fromX == 3
  2191.             && board[fromY][fromX] == BlackKing
  2192.             && toY == 7 && toX == 1) {
  2193.      *moveType = BlackQueenSideCastleWild;
  2194.      board[fromY][fromX] = EmptySquare;
  2195.      board[toY][toX] = BlackKing;
  2196.      board[fromY][0] = EmptySquare;
  2197.      board[toY][2] = BlackRook;
  2198.     } else if (fromY == 1
  2199.            && board[fromY][fromX] == BlackPawn
  2200.            && toY == 0) {
  2201.     /* black pawn promotion */
  2202.     board[0][toX] = PromoPiece(*moveType);
  2203.     if (board[0][toX] == EmptySquare) {
  2204.         board[0][toX] = BlackQueen;
  2205.         *moveType = BlackPromotionQueen;
  2206.     }
  2207.     board[1][fromX] = EmptySquare;
  2208.     } else if ((fromY == 3)
  2209.            && (toX != fromX)
  2210.            && (board[fromY][fromX] == BlackPawn)
  2211.            && (board[toY][toX] == EmptySquare)) {
  2212.     *moveType = BlackCapturesEnPassant;
  2213.     board[fromY][fromX] = EmptySquare;
  2214.     board[toY][toX] = BlackPawn;
  2215.     board[toY + 1][toX] = EmptySquare;
  2216.     } else {
  2217.     *moveType = NormalMove;
  2218.     board[toY][toX] = board[fromY][fromX];
  2219.     board[fromY][fromX] = EmptySquare;
  2220.     }
  2221. }
  2222.  
  2223. /*
  2224.  * MakeMove() displays moves.  If they are illegal, GNU chess will detect
  2225.  * this and send an Illegal move message.  XBoard will then retract the move.
  2226.  *
  2227.  * Oddity: moveType is ignored on input unless the move is seen to be a
  2228.  * pawn promotion, in which case moveType tells us what to promote to.
  2229.  */
  2230. void MakeMove(moveType, fromX, fromY, toX, toY)
  2231.      ChessMove *moveType;
  2232.      int fromX, fromY, toX, toY;
  2233. {
  2234.     CommentPopDown();
  2235.     forwardMostMove++;
  2236.     if (commentList[forwardMostMove] != NULL) {
  2237.     free(commentList[forwardMostMove]);
  2238.     commentList[forwardMostMove] = NULL;
  2239.     }
  2240.     CopyBoard(boards[forwardMostMove], boards[forwardMostMove - 1]);
  2241.     ApplyMove(moveType, fromX, fromY, toX, toY,
  2242.           boards[forwardMostMove]);
  2243.     endMessage[0] = NULLCHAR;
  2244.     (void) CoordsToAlgebraic(fromX, fromY, toX, toY,
  2245.                  ToLower(PieceToChar(PromoPiece(*moveType))),
  2246.                  forwardMostMove - 1,
  2247.                  parseList[forwardMostMove - 1]);
  2248.     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
  2249.     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
  2250.  
  2251.     if (pausing && gameMode != PlayFromGameFile) return;
  2252.     
  2253.     currentMove = forwardMostMove;
  2254.  
  2255.     if ((gameMode == PlayFromGameFile) &&
  2256.     (matchMode || (appData.timeDelay == 0 && !pausing))) return;
  2257.  
  2258.     SwitchClocks();
  2259.     DisplayMove(currentMove - 1);
  2260.     DrawPosition(FALSE, boards[currentMove]);
  2261. }
  2262.  
  2263. void InitChessProgram(hostName, programName, pr, isr, sendTime)
  2264.      char *hostName, *programName;
  2265.      ProcRef *pr;
  2266.      InputSourceRef *isr;
  2267.      int *sendTime;
  2268. {
  2269.     char cmdLine[MSG_SIZ];
  2270.     char buf[MSG_SIZ];
  2271.     int err;
  2272.     
  2273.     if (appData.noChessProgram) return;
  2274.     
  2275.     if (strcmp(hostName, "localhost") == 0) {
  2276.     if (*appData.searchTime != NULLCHAR) {
  2277.         sprintf(cmdLine, "%s %d", programName, searchTime);
  2278.     } else if (appData.searchDepth > 0) {
  2279.         sprintf(cmdLine, "%s 1 9999", programName);
  2280.     } else {
  2281.         sprintf(cmdLine, "%s %d %s", programName,
  2282.             appData.movesPerSession, appData.timeControl);
  2283.     }
  2284.     } else {
  2285.     if (*appData.searchTime != NULLCHAR) {
  2286.         sprintf(cmdLine, "%s %s %s %d",
  2287.             appData.remoteShell, hostName, programName, searchTime);
  2288.     } else if (appData.searchDepth > 0) {
  2289.         sprintf(cmdLine, "%s %s %s 1 9999",
  2290.             appData.remoteShell, hostName, programName);
  2291.     } else {
  2292.         sprintf(cmdLine, "%s %s %s %d %s",
  2293.             appData.remoteShell, hostName, programName,
  2294.             appData.movesPerSession, appData.timeControl);
  2295.     }
  2296.     }
  2297.     
  2298.     err = StartChildProcess(cmdLine, pr);
  2299.     if (err != 0) {
  2300.     sprintf(buf, "Startup failure on '%s'", programName);
  2301.     DisplayFatalError(buf, err);
  2302.     *pr = NoProc;
  2303.     return; /* don't actually exit */
  2304.     }
  2305.     
  2306. #ifdef NOTDEF
  2307. /*!!*/
  2308.     /* Read "Chess" */
  2309.     if (fgets(buf, MSG_SIZ, *from) == NULL) {
  2310.     sprintf(buf, "No response from '%s'", programName);
  2311.     DisplayFatalError(buf, errno);
  2312.     DestroyChildProcess(*pr);
  2313.     *pr = NULL;
  2314.     }
  2315. #endif
  2316.  
  2317.     *isr = AddInputSource(*pr, TRUE, ReceiveFromProgram);
  2318.  
  2319.     SendToProgram(appData.initString, *pr);
  2320.     SendSearchDepth(*pr);
  2321.     
  2322.     if (*sendTime == 2) {
  2323.     /* Does program have "time" command? */
  2324.     char buf[MSG_SIZ];
  2325.     
  2326.     sprintf(buf, "time %d\nhelp\n", blackTimeRemaining/10);
  2327.     /* "help" is a kludge to work around a gnuchess bug;
  2328.        some versions do not send a newline at the end of
  2329.        their response to the time command */
  2330.     SendToProgram(buf, *pr);
  2331.     }
  2332. }
  2333.  
  2334.  
  2335. void GameEnds(why)
  2336.      char *why;
  2337. {
  2338.     GameMode gm;
  2339.     
  2340.     gm = gameMode;
  2341.  
  2342.     if (appData.icsActive) {
  2343.     gameMode = IcsIdle;
  2344.     ics_gamenum = -1;
  2345.     ics_user_moved = FALSE;
  2346.     }
  2347.     (void) StopLoadGameTimer();
  2348.     if (gameFileFP != NULL) {
  2349.     gameFileFP = NULL;
  2350.     }
  2351.     StopClocks();
  2352.     
  2353.     if (why == NULL) return;
  2354.     
  2355.     strncpy(endMessage, why, MOVE_LEN * 4);
  2356.     endMessage[MOVE_LEN * 4 - 1] = NULLCHAR;
  2357.     if (currentMove == forwardMostMove)
  2358.       DisplayMove(currentMove - 1);
  2359.     
  2360.     if (forwardMostMove == 0) return;
  2361.     if (gm != PlayFromGameFile) {
  2362.     if (*appData.saveGameFile != NULLCHAR) {
  2363.         SaveGameToFile(appData.saveGameFile);
  2364.     } else if (appData.autoSaveGames) {
  2365.         AutoSaveGame();
  2366.     }
  2367.     if (*appData.savePositionFile != NULLCHAR) {
  2368.         SavePositionToFile(appData.savePositionFile);
  2369.     }
  2370.     }
  2371. }
  2372.  
  2373. void ShutdownChessPrograms(why)
  2374.      char *why;
  2375. {
  2376.     char *quit = "quit\n";
  2377.     int dummy;
  2378.  
  2379.     GameEnds(why);
  2380.     
  2381.     if (appData.icsActive) return;
  2382.  
  2383.     lastGameMode = gameMode;
  2384.     gameMode = EndOfGame;
  2385.     ModeHighlight();
  2386.     
  2387.     if (firstProgramISR != NULL)
  2388.       RemoveInputSource(firstProgramISR);
  2389.     firstProgramISR = NULL;
  2390.     
  2391.     if (firstProgramPR != NoProc) {
  2392.     OutputToProcess(firstProgramPR, quit, strlen(quit), &dummy);
  2393.     DestroyChildProcess(firstProgramPR);
  2394.     }
  2395.     firstProgramPR = NoProc;
  2396.     
  2397.     if (secondProgramISR != NULL)
  2398.       RemoveInputSource(secondProgramISR);
  2399.     secondProgramISR = NULL;
  2400.     
  2401.     if (secondProgramPR != NoProc) {
  2402.     OutputToProcess(secondProgramPR, quit, strlen(quit), &dummy);
  2403.     DestroyChildProcess(secondProgramPR);
  2404.     }
  2405.     secondProgramPR = NoProc;
  2406.     
  2407.     if (matchMode) {
  2408.     exit(0);
  2409.     }
  2410. }
  2411.  
  2412.  
  2413. /*
  2414.  * Button procedures
  2415.  */
  2416. void ExitEvent(status)
  2417.      int status;
  2418. {
  2419.     /* Save game if resource set and not already saved */
  2420.     if (*endMessage == NULLCHAR && forwardMostMove > 0) {
  2421.     if (*appData.saveGameFile != NULLCHAR) {
  2422.         SaveGameToFile(appData.saveGameFile);
  2423.     } else if (appData.autoSaveGames) {
  2424.         AutoSaveGame();
  2425.     }
  2426.     if (*appData.savePositionFile != NULLCHAR) {
  2427.         SavePositionToFile(appData.savePositionFile);
  2428.     }
  2429.     }
  2430.     ShutdownChessPrograms(NULL);
  2431.     if (icsPR != NoProc) {
  2432.     DestroyChildProcess(icsPR);
  2433.     }
  2434.     exit(status);
  2435. }
  2436.  
  2437. void CallFlagEvent()
  2438. {
  2439.     /* Call your opponent's flag (claim a win on time) */
  2440.     if (appData.icsActive) {
  2441.     SendToICS("flag\n");
  2442.     } else {
  2443.     switch (gameMode) {
  2444.       default:
  2445.         return;
  2446.       case MachinePlaysWhite:
  2447.         if (whiteFlag) {
  2448.         if (blackFlag)
  2449.           ShutdownChessPrograms("Draw (both players ran out of time)");
  2450.         else
  2451.           ShutdownChessPrograms("Black wins on time");
  2452.         }
  2453.         break;
  2454.       case MachinePlaysBlack:
  2455.         if (blackFlag) {
  2456.         if (whiteFlag)
  2457.           ShutdownChessPrograms("Draw (both players ran out of time)");
  2458.         else
  2459.           ShutdownChessPrograms("White wins on time");
  2460.         }
  2461.         break;
  2462.     }
  2463.     }
  2464. }
  2465.  
  2466. void DrawEvent()
  2467. {
  2468.     /* Offer draw or accept pending draw offer from opponent */
  2469.     
  2470.     if (appData.icsActive) {
  2471.     /* Note: tournament rules require draw offers to be
  2472.        made after you make your move but before you punch
  2473.        your clock.  Currently ICS doesn't let you do that;
  2474.        instead, you always punch your clock after making a
  2475.        move, but you can offer a draw at any time. */
  2476.     
  2477.     SendToICS("draw\n");
  2478.     } else {
  2479.     /* Currently GNU Chess doesn't offer or accept draws
  2480.        at all, so there is no Draw button in GNU Chess
  2481.        mode.  */
  2482.     
  2483.     DisplayError("Function not implemented", 0);
  2484.     }
  2485. }
  2486.  
  2487.  
  2488. void DeclineDrawEvent()
  2489. {
  2490.     /* Decline a pending draw offer from opponent */
  2491.     
  2492.     if (appData.icsActive) {
  2493.     /* Note: ICS also lets you withdraw your own draw
  2494.        offer with this command.  I'm not sure how long
  2495.        your draw offer remains pending if you don't
  2496.        withdraw it. */
  2497.     
  2498.     SendToICS("decline draw\n");
  2499.     } else {
  2500.     /* Currently GNU Chess doesn't offer or accept draws
  2501.        at all, so there is no Decline Draw button in
  2502.        GNU Chess mode.  */
  2503.     
  2504.     DisplayError("Function not implemented", 0);
  2505.     }
  2506. }
  2507.  
  2508. void AdjournEvent()
  2509. {
  2510.     /* Offer Adjourn or accept pending Adjourn offer from opponent */
  2511.     
  2512.     if (appData.icsActive) {
  2513.     SendToICS("adjourn\n");
  2514.     } else {
  2515.     /* Currently GNU Chess doesn't offer or accept Adjourns
  2516.        at all, so there is no Adjourn button in GNU Chess
  2517.        mode.  */
  2518.     
  2519.     DisplayError("Function not implemented", 0);
  2520.     }
  2521. }
  2522.  
  2523.  
  2524. void DeclineAdjournEvent()
  2525. {
  2526.     /* Decline a pending Adjourn offer from opponent */
  2527.     
  2528.     if (appData.icsActive) {
  2529.     /* Note: ICS also lets you withdraw your own Adjourn
  2530.        offer with this command.  I'm not sure how long
  2531.        your Adjourn offer remains pending if you don't
  2532.        withdraw it. */
  2533.     
  2534.     SendToICS("decline adjourn\n");
  2535.     } else {
  2536.     /* Currently GNU Chess doesn't offer or accept Adjourns
  2537.        at all, so there is no Decline Adjourn button in
  2538.        GNU Chess mode.  */
  2539.     
  2540.     DisplayError("Function not implemented", 0);
  2541.     }
  2542. }
  2543.  
  2544. void AbortEvent()
  2545. {
  2546.     /* Offer Abort or accept pending Abort offer from opponent */
  2547.     
  2548.     if (appData.icsActive) {
  2549.     SendToICS("abort\n");
  2550.     } else {
  2551.     DisplayError("Function not implemented", 0);
  2552.     }
  2553. }
  2554.  
  2555.  
  2556. void DeclineAbortEvent()
  2557. {
  2558.     /* Decline a pending Abort offer from opponent */
  2559.     
  2560.     if (appData.icsActive) {
  2561.     /* Note: ICS also lets you withdraw your own Abort
  2562.        offer with this command.  I'm not sure how long
  2563.        your Abort offer remains pending if you don't
  2564.        withdraw it. */
  2565.     
  2566.     SendToICS("decline abort\n");
  2567.     } else {
  2568.     /* Currently GNU Chess doesn't offer or accept Aborts
  2569.        at all, so there is no Decline Abort button in
  2570.        GNU Chess mode.  */
  2571.     
  2572.     DisplayError("Function not implemented", 0);
  2573.     }
  2574. }
  2575.  
  2576.  
  2577. void ResignEvent()
  2578. {
  2579.     /* Resign.  You can do this even if it's not your turn. */
  2580.     
  2581.     if (appData.icsActive) {
  2582.     SendToICS("resign\n");
  2583.     } else {
  2584.     switch (gameMode) {
  2585.       case MachinePlaysWhite:
  2586.         ShutdownChessPrograms("Black resigns");
  2587.         break;
  2588.       case MachinePlaysBlack:
  2589.         ShutdownChessPrograms("White resigns");
  2590.         break;
  2591.       default:
  2592.         break;
  2593.     }
  2594.     }
  2595. }
  2596.  
  2597.  
  2598. int LoadPositionFromFile(filename, n)
  2599.      char *filename;
  2600.      int n;
  2601. {
  2602.     FILE *f;
  2603.     char buf[MSG_SIZ];
  2604.     int ret;
  2605.  
  2606.     f = fopen(filename, "r");
  2607.     if (f == NULL) {
  2608.     sprintf(buf, "Can't open %s", filename);
  2609.     DisplayError(buf, errno);
  2610.     return FALSE;
  2611.     } else {
  2612.     ret = LoadPosition(f, n);
  2613.     return ret;
  2614.     }
  2615. }
  2616.  
  2617. int LoadPosition(fp, positionNumber)
  2618.      FILE *fp;
  2619.      int positionNumber;
  2620. {
  2621.     char *p, line[MSG_SIZ];
  2622.     Board initial_position;
  2623.     int i, j;
  2624.     
  2625.     if (gameMode != BeginningOfGame) {
  2626.     Reset(TRUE);
  2627.     }
  2628.  
  2629.     lastGameMode = gameMode = ForceMoves;
  2630.     ModeHighlight();
  2631.     startedFromSetupPosition = TRUE;
  2632.     
  2633.     if (firstProgramPR == NoProc)
  2634.       InitChessProgram(appData.firstHost, appData.firstChessProgram,
  2635.                &firstProgramPR, &firstProgramISR, &firstSendTime);
  2636.     
  2637.     if (positionNumber < 2) {
  2638.     /* Backward compatibility---don't look for '#' */
  2639.     (void) fgets(line, MSG_SIZ, fp);
  2640.     } else {
  2641.     while (positionNumber > 0) {
  2642.         /* skip postions before number positionNumber */
  2643.         if (fgets(line, MSG_SIZ, fp) == NULL) {
  2644.         Reset(TRUE);
  2645.         DisplayError("Position not found in file", 0);
  2646.         return FALSE;
  2647.         }
  2648.         if (line[0] == '#') positionNumber--;
  2649.     }
  2650.     }
  2651.  
  2652.     (void) fgets(line, MSG_SIZ, fp);
  2653.     (void) fgets(line, MSG_SIZ, fp);
  2654.     
  2655.     for (i = BOARD_SIZE - 1; i >= 0; i--) {
  2656.     (void) fgets(line, MSG_SIZ, fp);
  2657.     for (p = line, j = 0; j < BOARD_SIZE; p++) {
  2658.         if (*p == ' ')
  2659.           continue;
  2660.         initial_position[i][j++] = CharToPiece(*p);
  2661.     }
  2662.     }
  2663.     
  2664.     blackPlaysFirst = FALSE;
  2665.     if (!feof(fp)) {
  2666.     (void) fgets(line, MSG_SIZ, fp);
  2667.     if (strncmp(line, "black", strlen("black"))==0)
  2668.       blackPlaysFirst = TRUE;
  2669.     }
  2670.     fclose(fp);
  2671.     
  2672.     if (blackPlaysFirst) {
  2673.     CopyBoard(boards[0], initial_position);
  2674.     strcpy(moveList[0], "");
  2675.     strcpy(parseList[0], "");
  2676.     currentMove = forwardMostMove = backwardMostMove = 1;
  2677.     CopyBoard(boards[1], initial_position);
  2678.     SendToProgram("force\na3\n", firstProgramPR);
  2679.     SendCurrentBoard(firstProgramPR);
  2680.     DisplayMessage("Black to play");
  2681.     } else {
  2682.     currentMove = forwardMostMove = backwardMostMove = 0;
  2683.     CopyBoard(boards[0], initial_position);
  2684.     SendCurrentBoard(firstProgramPR);
  2685.     SendToProgram("force\n", firstProgramPR);
  2686.     DisplayMessage("White to play");
  2687.     }
  2688.     
  2689.     ResetClocks();
  2690.     timeRemaining[0][1] = whiteTimeRemaining;
  2691.     timeRemaining[1][1] = blackTimeRemaining;
  2692.  
  2693.     DrawPosition(FALSE, boards[currentMove]);
  2694.     
  2695.     return TRUE;
  2696. }
  2697.  
  2698.  
  2699. int LoadGameFromFile(filename, n)
  2700.      char *filename;
  2701.      int n;
  2702. {
  2703.     FILE *f;
  2704.     char buf[MSG_SIZ];
  2705.     int ret;
  2706.  
  2707.     f = fopen(filename, "r");
  2708.     if (f == NULL) {
  2709.     sprintf(buf, "Can't open %s", filename);
  2710.     DisplayError(buf, errno);
  2711.     return FALSE;
  2712.     } else {
  2713.     ret = LoadGame(f, n);
  2714.     return ret;
  2715.     }
  2716. }
  2717.  
  2718.  
  2719. FILE *lastLoadGameFP = NULL;
  2720. int lastLoadGameNumber = 0;
  2721.  
  2722. int ReloadGame(offset)
  2723.      int offset;
  2724. {
  2725.     if (lastLoadGameFP == NULL) {
  2726.     DisplayError("No game has been loaded", 0);
  2727.     return FALSE;
  2728.     }
  2729.     rewind(lastLoadGameFP);
  2730.     return LoadGame(lastLoadGameFP, lastLoadGameNumber + offset);
  2731. }
  2732.  
  2733. int LoadGame(f, gameNumber)
  2734.      FILE *f;
  2735.      int gameNumber;
  2736. {
  2737.     ChessMove cm, lastStart;
  2738.  
  2739.     if (gameMode != BeginningOfGame) {
  2740.     Reset(FALSE);
  2741.     }
  2742.  
  2743.     yynewfile(f);
  2744.     gameFileFP = f;
  2745.     if (lastLoadGameFP != NULL && lastLoadGameFP != f) {
  2746.     fclose(lastLoadGameFP);
  2747.     }
  2748.     lastLoadGameFP = f;
  2749.     lastLoadGameNumber = gameNumber;
  2750.  
  2751.     lastGameMode = gameMode = PlayFromGameFile;
  2752.     ModeHighlight();
  2753.     InitPosition(FALSE);
  2754.     StopClocks();
  2755.     if (firstProgramPR == NoProc) {
  2756.     InitChessProgram(appData.firstHost, appData.firstChessProgram,
  2757.              &firstProgramPR, &firstProgramISR, &firstSendTime);
  2758.     } else {
  2759.     SendToProgram(appData.initString, firstProgramPR);
  2760.     SendSearchDepth(firstProgramPR);
  2761.     }
  2762.     SendToProgram("force\n", firstProgramPR);
  2763.     
  2764.     /*
  2765.      * Skip the first gameNumber-1 games in the file.
  2766.      * Also skip over anything that precedes an identifiable 
  2767.      * start of game marker, to avoid being confused by 
  2768.      * garbage at the start of the file.  Currently 
  2769.      * recognized start of game markers are the move number "1",
  2770.      * the pattern "gnuchess .* game", and the pattern
  2771.      * "^# [^ ]* game file".  A game that starts with the
  2772.      * latter pattern will also have a move number 1, possibly
  2773.      * following a position diagram.
  2774.      */
  2775.     lastStart = (ChessMove) 0;
  2776.     while (gameNumber > 0) {
  2777.     yyboardindex = forwardMostMove;
  2778.     cm = (ChessMove) yylex();
  2779.     switch (cm) {
  2780.       case (ChessMove) 0:
  2781.         Reset(TRUE);
  2782.         DisplayError("Game not found in file", 0);
  2783.         return FALSE;
  2784.  
  2785.       case GNUChessGame:
  2786.       case XBoardGame:
  2787.         gameNumber--;
  2788.         lastStart = cm;
  2789.         break;
  2790.         
  2791.       case MoveNumberOne:
  2792.         if (lastStart == MoveNumberOne || lastStart == (ChessMove) 0) {
  2793.         gameNumber--;
  2794.         lastStart = cm;
  2795.         } else if (lastStart == XBoardGame) {
  2796.         lastStart = cm;
  2797.         }
  2798.         break;
  2799.  
  2800.       default:
  2801.         break;
  2802.     }
  2803.     }
  2804.     
  2805.     if (appData.debugMode)
  2806.       fprintf(debugFP, "Parsed game start '%s' (%d)\n", yytext, (int) cm);
  2807.  
  2808.     if (lastStart == XBoardGame) {
  2809.     /* Skip header junk before position diagram and/or move 1 */
  2810.     for (;;) {
  2811.         int i, j;
  2812.         char *p;
  2813.         Board initial_position;
  2814.  
  2815.         yyboardindex = forwardMostMove;
  2816.         cm = (ChessMove) yylex();
  2817.  
  2818.         if (appData.debugMode)
  2819.           fprintf(debugFP, "Parsed '%s' (%d)\n", yytext, (int) cm);
  2820.  
  2821.         switch (cm) {
  2822.           default:
  2823.         continue;
  2824.  
  2825.           case (ChessMove) 0:
  2826.           case GNUChessGame:
  2827.           case XBoardGame:
  2828.         Reset(TRUE);
  2829.         DisplayMessage("No moves in game");
  2830.         return FALSE;
  2831.  
  2832.           case MoveNumberOne:
  2833.         break;
  2834.  
  2835.           case PositionDiagram:
  2836.         p = yytext;
  2837.         for (i = BOARD_SIZE - 1; i >= 0; i--)
  2838.           for (j = 0; j < BOARD_SIZE; p++)
  2839.             switch (*p) {
  2840.               case '[':
  2841.               case '-':
  2842.               case ' ':
  2843.               case '\t':
  2844.               case '\n':
  2845.               case '\r':
  2846.             break;
  2847.               default:
  2848.             initial_position[i][j++] = CharToPiece(*p);
  2849.             break;
  2850.             }
  2851.         while (*p == ' ' || *p == '\t' ||
  2852.                *p == '\n' || *p == '\r') p++;
  2853.     
  2854.         if (strncmp(p, "black", strlen("black"))==0)
  2855.           blackPlaysFirst = TRUE;
  2856.         else
  2857.           blackPlaysFirst = FALSE;
  2858.         startedFromSetupPosition = TRUE;
  2859.     
  2860.         if (blackPlaysFirst) {
  2861.             currentMove = forwardMostMove = backwardMostMove = 1;
  2862.             CopyBoard(boards[0], initial_position);
  2863.             CopyBoard(boards[1], initial_position);
  2864.             strcpy(moveList[0], "");
  2865.             strcpy(parseList[0], "");
  2866.             timeRemaining[0][1] = whiteTimeRemaining;
  2867.             timeRemaining[1][1] = blackTimeRemaining;
  2868.             SendToProgram("a3\n", firstProgramPR);
  2869.             SendCurrentBoard(firstProgramPR);
  2870.         } else {
  2871.             currentMove = forwardMostMove = backwardMostMove = 0;
  2872.             CopyBoard(boards[0], initial_position);
  2873.             SendCurrentBoard(firstProgramPR);
  2874.         }
  2875.         break;
  2876.  
  2877.           case Comment:
  2878.         if (appData.debugMode) 
  2879.           fprintf(debugFP, "Parsed Comment: %s\n", yytext);
  2880.         if (!matchMode && (pausing || appData.timeDelay != 0)) {
  2881.             CommentPopUp(yytext);
  2882.         }
  2883.         AppendComment(currentMove, yytext);
  2884.         if (!matchMode && appData.timeDelay != 0) {
  2885.             DrawPosition(FALSE, boards[currentMove]);
  2886.             if (appData.timeDelay > 0)
  2887.               StartLoadGameTimer((long)(1000.0 * appData.timeDelay));
  2888.             return TRUE;
  2889.         }
  2890.         break;
  2891.         }
  2892.         break;
  2893.     }
  2894.     }
  2895.  
  2896.     if (!matchMode && appData.timeDelay != 0)
  2897.       DrawPosition(FALSE, boards[currentMove]);
  2898.  
  2899.     LoadGameLoop();
  2900.     
  2901.     return TRUE;
  2902. }
  2903.  
  2904. void ResurrectChessProgram()
  2905.      /* Get out of EndOfGame mode.  This may require us to restart the
  2906.     chess program and feed it all the moves made so far. */
  2907. {
  2908.     int i;
  2909.     
  2910.     /* assert(gameMode == EndOfGame) */
  2911.     
  2912.     gameMode = lastGameMode = ForceMoves;
  2913.     ModeHighlight();
  2914.     
  2915.     if (firstProgramPR != NoProc) return;
  2916.     
  2917.     InitChessProgram(appData.firstHost, appData.firstChessProgram,
  2918.              &firstProgramPR, &firstProgramISR, &firstSendTime);
  2919.     SendToProgram("force\n", firstProgramPR);
  2920.     
  2921.     if (startedFromSetupPosition) {
  2922.     if (backwardMostMove % 2 == 1)
  2923.       SendToProgram("a3\n", firstProgramPR);
  2924.     SendBoard(firstProgramPR, boards[backwardMostMove]);
  2925.     }
  2926.     
  2927.     for (i = backwardMostMove; i < currentMove; i++) {
  2928.     SendToProgram(moveList[i], firstProgramPR);
  2929.     }
  2930.     
  2931.     if (!firstSendTime) {
  2932.     /* can't tell gnuchess what its clock should read,
  2933.        so we bow to its notion. */
  2934.     ResetClocks();
  2935.     timeRemaining[0][currentMove] = whiteTimeRemaining;
  2936.     timeRemaining[1][currentMove] = blackTimeRemaining;
  2937.     }
  2938. }
  2939.  
  2940. void MachineBlackEvent()
  2941. {
  2942.     if (pausing) PauseEvent();
  2943.     if (gameMode == PlayFromGameFile) ForceMovesEvent();
  2944.     if (gameMode == EditPosition) EditPositionDone();
  2945.     
  2946.     if ((gameMode == EndOfGame) ||
  2947.     (appData.noChessProgram) || (gameMode == MachinePlaysBlack))
  2948.       return;
  2949.     
  2950.     if (WhiteOnMove(gameMode == ForceMoves ? currentMove : forwardMostMove)) {
  2951.     DisplayError("It is not Black's turn", 0);
  2952.     return;
  2953.     }
  2954.     if (gameMode == TwoMachinesPlay) ForceMovesEvent();
  2955.     
  2956.     if (gameMode == ForceMoves) forwardMostMove = currentMove;
  2957.     
  2958.     lastGameMode = gameMode = MachinePlaysBlack;
  2959.     ModeHighlight();
  2960.     SendToProgram(appData.blackString, firstProgramPR);
  2961.     StartClocks();
  2962. }
  2963.  
  2964. void ForwardInner(target)
  2965.      int target;
  2966. {
  2967.     if (gameMode == EditPosition)
  2968.       return;
  2969.     
  2970.     if (gameMode == PlayFromGameFile && !pausing)
  2971.       PauseEvent();
  2972.     
  2973.     if (currentMove >= forwardMostMove) {
  2974.     if (gameFileFP != NULL)
  2975.       (void) LoadGameOneMove();
  2976.     return;
  2977.     }
  2978.     
  2979.     if (gameMode == ForceMoves) {
  2980.     while (currentMove < target) {
  2981.         SendToProgram(moveList[currentMove++], firstProgramPR);
  2982.     }
  2983.     } else {
  2984.     currentMove = target;
  2985.     }
  2986.     
  2987.     if (gameMode == ForceMoves) {
  2988.     whiteTimeRemaining = timeRemaining[0][currentMove];
  2989.     blackTimeRemaining = timeRemaining[1][currentMove];
  2990.     }
  2991.     DisplayBothClocks();
  2992.     DisplayMove(currentMove - 1);
  2993.     DrawPosition(FALSE, boards[currentMove]);
  2994.     if (commentList[currentMove] == NULL) {
  2995.     CommentPopDown();
  2996.     } else {
  2997.     CommentPopUp(commentList[currentMove]);
  2998.     }
  2999. }
  3000.  
  3001.  
  3002. void ForwardEvent()
  3003. {
  3004.     ForwardInner(currentMove + 1);
  3005. }
  3006.  
  3007. void ToEndEvent()
  3008. {
  3009.     ForwardInner(forwardMostMove);
  3010. }
  3011.  
  3012. void Reset(redraw)
  3013.      int redraw;
  3014. {
  3015.     int i;
  3016.  
  3017.     pausing = FALSE;
  3018.     flipView = appData.flipView;
  3019.     startedFromSetupPosition = blackPlaysFirst = FALSE;
  3020.     firstMove = TRUE;
  3021.     whiteFlag = blackFlag = FALSE;
  3022.     maybeThinking = FALSE;
  3023.     endMessage[0] = NULLCHAR;
  3024.     ics_white[0] = ics_black[0] = NULLCHAR;
  3025.     ics_user_moved = FALSE;
  3026.     ics_getting_history = H_FALSE;
  3027.     ics_gamenum = -1;
  3028.     
  3029.     ResetFrontEnd();
  3030.  
  3031.     ShutdownChessPrograms(NULL);
  3032.     lastGameMode = gameMode = BeginningOfGame;
  3033.     ModeHighlight();
  3034.     InitPosition(redraw);
  3035.     for (i = 0; i < MAX_MOVES; i++) {
  3036.     if (commentList[i] != NULL) {
  3037.         free(commentList[i]);
  3038.         commentList[i] = NULL;
  3039.     }
  3040.     }
  3041.     ResetClocks();
  3042.     timeRemaining[0][0] = whiteTimeRemaining;
  3043.     timeRemaining[1][0] = blackTimeRemaining;
  3044.     InitChessProgram(appData.firstHost, appData.firstChessProgram,
  3045.              &firstProgramPR, &firstProgramISR, &firstSendTime);
  3046.     DisplayTitle("");
  3047.     DisplayMessage("");
  3048. }
  3049.  
  3050.  
  3051. void EditPositionEvent()
  3052. {
  3053.     if (gameMode == EditPosition) {
  3054.     ForceMovesEvent();
  3055.     return;
  3056.     }
  3057.     
  3058.     ForceMovesEvent();
  3059.     if (gameMode != ForceMoves) return;
  3060.     
  3061.     lastGameMode = gameMode = EditPosition;
  3062.     ModeHighlight();
  3063.     if (currentMove > 0)
  3064.       CopyBoard(boards[0], boards[currentMove]);
  3065.     
  3066.     blackPlaysFirst = !WhiteOnMove(currentMove);
  3067.     ResetClocks();
  3068.     currentMove = forwardMostMove = backwardMostMove = 0;
  3069. }
  3070.  
  3071. void EditPositionDone()
  3072. {
  3073.     startedFromSetupPosition = TRUE;
  3074.     SendToProgram(appData.initString, firstProgramPR);
  3075.     SendSearchDepth(firstProgramPR);
  3076.     if (blackPlaysFirst) {
  3077.     strcpy(moveList[0], "");
  3078.     strcpy(parseList[0], "");
  3079.     currentMove = forwardMostMove = backwardMostMove = 1;
  3080.     CopyBoard(boards[1], boards[0]);
  3081.     SendToProgram("force\na3\n", firstProgramPR);
  3082.     SendCurrentBoard(firstProgramPR);
  3083.     DisplayTitle("");
  3084.     DisplayMessage("Black to play");
  3085.     } else {
  3086.     currentMove = forwardMostMove = backwardMostMove = 0;
  3087.     SendCurrentBoard(firstProgramPR);
  3088.     SendToProgram("force\n", firstProgramPR);
  3089.     DisplayTitle("");
  3090.     DisplayMessage("White to play");
  3091.     }
  3092.     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
  3093.     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
  3094.     lastGameMode = gameMode = ForceMoves;
  3095. }
  3096.  
  3097. void SetWhiteToPlayEvent()
  3098. {
  3099.     if (gameMode != EditPosition) return;
  3100.     blackPlaysFirst = FALSE;
  3101.     DisplayBothClocks(); /* works because currentMove is 0 */
  3102. }
  3103.  
  3104. void SetBlackToPlayEvent()
  3105. {
  3106.     if (gameMode != EditPosition) return;
  3107.     blackPlaysFirst = TRUE;
  3108.     currentMove = 1;    /* kludge */
  3109.     DisplayBothClocks();
  3110.     currentMove = 0;
  3111. }
  3112.  
  3113. void EditPositionMenuEvent(selection, x, y)
  3114.      ChessSquare selection;
  3115.      int x, y;
  3116. {
  3117.     if (gameMode != EditPosition) return;
  3118.     switch (selection) {
  3119.       case ClearBoard:
  3120.     for (x = 0; x < BOARD_SIZE; x++)
  3121.       for (y = 0; y < BOARD_SIZE; y++)
  3122.         boards[0][y][x] = EmptySquare;
  3123.     DrawPosition(FALSE, boards[0]);
  3124.     break;
  3125.  
  3126.       case WhitePlay:
  3127.     SetWhiteToPlayEvent();
  3128.     break;
  3129.  
  3130.       case BlackPlay:
  3131.     SetBlackToPlayEvent();
  3132.     break;
  3133.  
  3134.       default:
  3135.     boards[0][y][x] = selection;
  3136.     DrawPosition(FALSE, boards[0]);
  3137.     break;
  3138.     }
  3139. }
  3140.  
  3141.  
  3142. void MachineWhiteEvent()
  3143. {
  3144.     if (pausing) PauseEvent();
  3145.     if (gameMode == PlayFromGameFile) ForceMovesEvent();
  3146.     if (gameMode == EditPosition) EditPositionDone();
  3147.     
  3148.     if ((gameMode == EndOfGame) ||
  3149.     (appData.noChessProgram) || (gameMode == MachinePlaysWhite))
  3150.       return;
  3151.     
  3152.     if (!WhiteOnMove(gameMode == ForceMoves ? currentMove : forwardMostMove)) {
  3153.     DisplayError("It is not White's turn", 0);
  3154.     return;
  3155.     }
  3156.     
  3157.     if (gameMode == TwoMachinesPlay) ForceMovesEvent();
  3158.  
  3159.     if (gameMode == ForceMoves) forwardMostMove = currentMove;
  3160.     
  3161.     lastGameMode = gameMode = MachinePlaysWhite;
  3162.     ModeHighlight();
  3163.     SendToProgram(appData.whiteString, firstProgramPR);
  3164.     StartClocks();
  3165. }
  3166.  
  3167. void BackwardInner(target)
  3168.      int target;
  3169. {
  3170.     if ((currentMove <= backwardMostMove) || (gameMode == EditPosition))
  3171.       return;
  3172.     
  3173.     if (gameMode == EndOfGame)
  3174.       ResurrectChessProgram();
  3175.     
  3176.     if (gameMode == PlayFromGameFile && !pausing)
  3177.       PauseEvent();
  3178.     
  3179.     if (gameMode == ForceMoves) {
  3180.     Attention(firstProgramPR);
  3181.     while (currentMove > target) {
  3182.         SendToProgram("undo\n", firstProgramPR);
  3183.         currentMove--;
  3184.     }
  3185.     } else {
  3186.     currentMove = target;
  3187.     }
  3188.     
  3189.     if (gameMode == ForceMoves) {
  3190.     whiteTimeRemaining = timeRemaining[0][currentMove];
  3191.     blackTimeRemaining = timeRemaining[1][currentMove];
  3192.     }
  3193.     DisplayBothClocks();
  3194.     DisplayMove(currentMove - 1);
  3195.     DrawPosition(FALSE, boards[currentMove]);
  3196.     if (commentList[currentMove] == NULL) {
  3197.     CommentPopDown();
  3198.     } else {
  3199.     CommentPopUp(commentList[currentMove]);
  3200.     }
  3201. }
  3202.  
  3203. void BackwardEvent()
  3204. {
  3205.     BackwardInner(currentMove - 1);
  3206. }
  3207.  
  3208. void ToStartEvent()
  3209. {
  3210.     BackwardInner(backwardMostMove);
  3211. }
  3212.  
  3213.  
  3214. void FlipViewEvent()
  3215. {
  3216.     flipView = !flipView;
  3217.     DrawPosition(FALSE, boards[currentMove]);
  3218. }
  3219.  
  3220. char *DefaultFileName(ext)
  3221.      char *ext;
  3222. {
  3223.     static char def[MSG_SIZ];
  3224.  
  3225.     if (appData.icsActive && ics_white[0] != NULLCHAR) {
  3226.     sprintf(def, "%s-%s.%s", ics_white, ics_black, ext);
  3227.     } else {
  3228.     def[0] = NULLCHAR;
  3229.     }
  3230.  
  3231.     return def;
  3232. }
  3233.  
  3234. int SaveGameToFile(filename)
  3235.      char *filename;
  3236. {
  3237.     FILE *f;
  3238.     char buf[MSG_SIZ];
  3239.  
  3240.     f = fopen(filename, "a");
  3241.     if (f == NULL) {
  3242.     sprintf(buf, "Can't open %s", filename);
  3243.     DisplayError(buf, errno);
  3244.     return FALSE;
  3245.     } else {
  3246.     SaveGame(f, 0);
  3247.     return TRUE;
  3248.     }
  3249. }
  3250.  
  3251. int SaveGame(f, dummy)
  3252.      FILE *f;
  3253.      int dummy;
  3254. {
  3255.     int i;
  3256.     time_t tm;
  3257.     
  3258.     tm = time((time_t *) NULL);
  3259.     
  3260.     fprintf(f, "# %s game file -- %s", programName, ctime(&tm));
  3261.     PrintOpponents(f);
  3262.     fprintf(f, "\talgebraic\n");
  3263.     
  3264.     if (backwardMostMove > 0 || startedFromSetupPosition) {
  3265.     fprintf(f, "[--------------\n");
  3266.     PrintPosition(f, backwardMostMove);
  3267.     fprintf(f, "--------------]\n");
  3268.     }
  3269.  
  3270.     i = backwardMostMove;
  3271.  
  3272.     while (i < forwardMostMove) {
  3273.     if (commentList[i] != NULL)
  3274.       fprintf(f, "%s\n", commentList[i]);
  3275.  
  3276.     if ((i % 2) == 1) {
  3277.         fprintf(f, "%d. ...  %s\n", i/2 + 1, parseList[i]);
  3278.         i++;
  3279.     } else {
  3280.         fprintf(f, "%d. %s  ", i/2 + 1, parseList[i]);
  3281.         i++;
  3282.         if (commentList[i] != NULL) {
  3283.         fprintf(f, "\n");
  3284.         continue;
  3285.         }
  3286.         if (i >= forwardMostMove) {
  3287.         fprintf(f, "\n");
  3288.         break;
  3289.         }
  3290.         fprintf(f, "%s\n", parseList[i]);
  3291.         i++;
  3292.     }
  3293.     }
  3294.     
  3295.     if (commentList[i] != NULL)
  3296.       fprintf(f, "%s\n", commentList[i]);
  3297.     
  3298.     if (endMessage[0] != NULLCHAR)
  3299.       fprintf(f, "%s\n", endMessage);
  3300.  
  3301.     fclose(f);
  3302.     return TRUE;
  3303. }
  3304.  
  3305. #ifdef notdef  
  3306. /* currently unused */
  3307. void SwitchEvent()
  3308. {
  3309.     if (appData.noChessProgram) return;
  3310.     if (pausing) PauseEvent();
  3311.     switch (gameMode) {
  3312.       default:
  3313.     return;
  3314.       case MachinePlaysWhite:
  3315.     if (WhiteOnMove(forwardMostMove)) {
  3316.         DisplayError("Wait until your turn", 0);
  3317.         return;
  3318.     }
  3319.     lastGameMode = gameMode = MachinePlaysBlack;
  3320.     ModeHighlight();
  3321.     break;
  3322.       case BeginningOfGame:
  3323.       case MachinePlaysBlack:
  3324.     if (!WhiteOnMove(forwardMostMove)) {
  3325.         DisplayError("Wait until your turn", 0);
  3326.         return;
  3327.     }
  3328.     if (forwardMostMove == 0) {
  3329.         MachineWhiteEvent();
  3330.         return;
  3331.     }
  3332.     lastGameMode = gameMode = MachinePlaysWhite;
  3333.     ModeHighlight();
  3334.     break;
  3335.     }
  3336.     
  3337.     Attention(firstProgramPR);
  3338.     SendToProgram("switch\n", firstProgramPR);
  3339. }
  3340. #endif /*notdef*/
  3341.  
  3342. void ForceMovesEvent()
  3343. {
  3344.     int i;
  3345.     char str[MSG_SIZ];
  3346.     
  3347.     if (pausing) PauseEvent();
  3348.     switch (gameMode) {
  3349.       case MachinePlaysWhite:
  3350.     if (WhiteOnMove(forwardMostMove)) {
  3351.         DisplayError("Wait until your turn", 0);
  3352.         return;
  3353.     }
  3354.     Attention(firstProgramPR);
  3355.     SendToProgram("force\n", firstProgramPR);
  3356.     break;
  3357.       case MachinePlaysBlack:
  3358.     if (!WhiteOnMove(forwardMostMove)) {
  3359.         DisplayError("Wait until your turn", 0);
  3360.         return;
  3361.     }
  3362.     Attention(firstProgramPR);
  3363.     SendToProgram("force\n", firstProgramPR);
  3364.     break;
  3365.       case BeginningOfGame:
  3366.     SendToProgram("force\n", firstProgramPR);
  3367.     break;
  3368.       case PlayFromGameFile:
  3369.         (void) StopLoadGameTimer();
  3370.     if (gameFileFP != NULL) {
  3371.         gameFileFP = NULL;
  3372.     }
  3373.     break;
  3374.       case EndOfGame:
  3375.     ResurrectChessProgram();
  3376.     return;
  3377.       case EditPosition:
  3378.     EditPositionDone();
  3379.     break;
  3380.       case TwoMachinesPlay:
  3381.     ShutdownChessPrograms(NULL);
  3382.     ResurrectChessProgram();
  3383.     return;
  3384.       case IcsPlayingBlack:
  3385.       case IcsPlayingWhite:
  3386.     DisplayError("Aren't you playing a game?  If not, use Reset and try again.", 0);
  3387.     return;
  3388.       case IcsObserving:
  3389.     SendToICS("observe\n");
  3390.     sprintf(str, "Aren't you observing game %d?  Attempting to stop observing it.",
  3391.             ics_gamenum);
  3392.     DisplayError(str, 0);
  3393.     break;
  3394.       case IcsIdle:
  3395.     break;
  3396.       default:
  3397.     return;
  3398.     }
  3399.     
  3400.     if (gameMode == MachinePlaysWhite ||
  3401.     gameMode == MachinePlaysBlack ||
  3402.     gameMode == TwoMachinesPlay ||
  3403.     gameMode == PlayFromGameFile) {
  3404.     i = forwardMostMove;
  3405.     while (i > currentMove) {
  3406.         SendToProgram("undo\n", firstProgramPR);
  3407.         i--;
  3408.     }
  3409.     whiteTimeRemaining = timeRemaining[0][currentMove];
  3410.     blackTimeRemaining = timeRemaining[1][currentMove];
  3411.     if (whiteFlag || blackFlag) {
  3412.         whiteFlag = blackFlag = 0;
  3413.     }
  3414.     DisplayTitle("");
  3415.     }        
  3416.     
  3417.     lastGameMode = gameMode = ForceMoves;
  3418.     ModeHighlight();
  3419.     
  3420.     StopClocks();
  3421. }
  3422.  
  3423.  
  3424. void IcsClientEvent()
  3425. {
  3426.     if (!appData.icsActive) return;
  3427.     switch (gameMode) {
  3428.       case IcsPlayingWhite:
  3429.       case IcsPlayingBlack:
  3430.       case IcsObserving:
  3431.       case IcsIdle:
  3432.       case BeginningOfGame:
  3433.     return;
  3434.  
  3435.       case ForceMoves:
  3436.     break;
  3437.  
  3438.       case EditPosition:
  3439.     EditPositionDone();
  3440.     break;
  3441.  
  3442.       default:
  3443.     ForceMovesEvent();
  3444.     break;
  3445.     }
  3446.  
  3447.     gameMode = IcsIdle;
  3448.     ModeHighlight();
  3449.     return;
  3450. }
  3451.  
  3452.  
  3453. void HintEvent()
  3454. {
  3455.     if (appData.noChessProgram) return;
  3456.     switch (gameMode) {
  3457.       case MachinePlaysWhite:
  3458.     if (WhiteOnMove(forwardMostMove)) {
  3459.         DisplayError("Wait until your turn", 0);
  3460.         return;
  3461.     }
  3462.     break;
  3463.       case BeginningOfGame:
  3464.       case MachinePlaysBlack:
  3465.     if (!WhiteOnMove(forwardMostMove)) {
  3466.         DisplayError("Wait until your turn", 0);
  3467.         return;
  3468.     }
  3469.     break;
  3470.       default:
  3471.     DisplayError("No hint available", 0);
  3472.     return;
  3473.     }
  3474.     Attention(firstProgramPR);
  3475.     SendToProgram("hint\n", firstProgramPR);
  3476. }
  3477.  
  3478. void PrintPosition(fp, move)
  3479.      FILE *fp;
  3480.      int move;
  3481. {
  3482.     int i, j;
  3483.     
  3484.     for (i = BOARD_SIZE - 1; i >= 0; i--) {
  3485.     for (j = 0; j < BOARD_SIZE; j++) {
  3486.         fprintf(fp, "%c", PieceToChar(boards[move][i][j]));
  3487.         fputc(j == BOARD_SIZE - 1 ? '\n' : ' ', fp);
  3488.     }
  3489.     }
  3490.     if ((gameMode == EditPosition) ? !blackPlaysFirst : (move % 2 == 0))
  3491.       fprintf(fp, "white to play\n");
  3492.     else
  3493.       fprintf(fp, "black to play\n");
  3494. }
  3495.  
  3496. void PrintOpponents(fp)
  3497.      FILE *fp;
  3498. {
  3499.     switch (lastGameMode) {
  3500.       case MachinePlaysWhite:
  3501.     fprintf(fp, "\t%s@%s vs. %s@%s\n", appData.firstChessProgram,
  3502.         appData.firstHost, UserName(), HostName());
  3503.     break;
  3504.       case MachinePlaysBlack:
  3505.     fprintf(fp, "\t%s@%s vs. %s@%s\n", UserName(),
  3506.         HostName(), appData.firstChessProgram,
  3507.         appData.firstHost);
  3508.     break;
  3509.       case TwoMachinesPlay:
  3510.     fprintf(fp, "\t%s@%s vs. %s@%s\n", appData.secondChessProgram,
  3511.         appData.secondHost, appData.firstChessProgram,
  3512.         appData.firstHost);
  3513.     break;
  3514.       default:
  3515.     if (appData.icsActive && ics_white[0] != NULLCHAR) {
  3516.         fprintf(fp, "\t%s vs. %s\n",
  3517.             ics_white, ics_black);
  3518.     } else {
  3519.         fprintf(fp, "\n");
  3520.     }
  3521.     break;
  3522.     }
  3523. }
  3524.  
  3525.  
  3526. int SavePositionToFile(filename)
  3527.      char *filename;
  3528. {
  3529.     FILE *f;
  3530.     char buf[MSG_SIZ];
  3531.  
  3532.     f = fopen(filename, "a");
  3533.     if (f == NULL) {
  3534.     sprintf(buf, "Can't open %s", filename);
  3535.     DisplayError(buf, errno);
  3536.     return FALSE;
  3537.     } else {
  3538.     SavePosition(f, 0);
  3539.     return TRUE;
  3540.     }
  3541. }
  3542.  
  3543. int SavePosition(f, dummy)
  3544.      FILE *f;
  3545.      int dummy;
  3546. {
  3547.     time_t tm;
  3548.     
  3549.     tm = time((time_t *) NULL);
  3550.     
  3551.     fprintf(f, "# %s position file -- %s", programName, ctime(&tm));
  3552.     PrintOpponents(f);
  3553.     fprintf(f, "[--------------\n");
  3554.     PrintPosition(f, currentMove);
  3555.     fprintf(f, "--------------]\n");
  3556.     fclose(f);
  3557.     return TRUE;
  3558. }
  3559.  
  3560. void TwoMachinesEvent()
  3561. {
  3562.     int i;
  3563.     
  3564.     if (pausing) PauseEvent();
  3565.     if (gameMode == PlayFromGameFile) ForceMovesEvent();
  3566.     if (appData.noChessProgram) return;
  3567.     
  3568.     switch (gameMode) {
  3569.       case EndOfGame:
  3570.       case TwoMachinesPlay:
  3571.     return;
  3572.       case MachinePlaysWhite:
  3573.       case MachinePlaysBlack:
  3574.       case BeginningOfGame:
  3575.     ForceMovesEvent();
  3576.     if (gameMode != ForceMoves) return;
  3577.     break;
  3578.       case EditPosition:
  3579.     EditPositionDone();
  3580.     break;
  3581.       case ForceMoves:
  3582.       default:
  3583.     break;
  3584.     }
  3585.     
  3586.     forwardMostMove = currentMove;
  3587.  
  3588.     InitChessProgram(appData.secondHost, appData.secondChessProgram,
  3589.              &secondProgramPR, &secondProgramISR, &secondSendTime);
  3590.     if (startedFromSetupPosition) {
  3591.     if (blackPlaysFirst) {
  3592.         SendToProgram("force\na3\n", secondProgramPR);
  3593.         SendBoard(secondProgramPR, boards[backwardMostMove]);
  3594.     } else {
  3595.         SendBoard(secondProgramPR, boards[backwardMostMove]);
  3596.         SendToProgram("force\n", secondProgramPR);
  3597.     }
  3598.     } else {
  3599.     SendToProgram("force\n", secondProgramPR);
  3600.     }
  3601.     for (i = backwardMostMove; i < forwardMostMove; i++) {
  3602.     SendToProgram(moveList[i], secondProgramPR);
  3603.     }
  3604.     lastGameMode = gameMode = TwoMachinesPlay;
  3605.     ModeHighlight();
  3606.     firstMove = TRUE;
  3607.     if (WhiteOnMove(forwardMostMove))
  3608.       SendToProgram(appData.whiteString, secondProgramPR);
  3609.     else
  3610.       SendToProgram(appData.blackString, firstProgramPR);
  3611.     
  3612.     if (!firstSendTime || !secondSendTime) {
  3613.     ResetClocks();
  3614.     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
  3615.     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
  3616.     }
  3617.     StartClocks();
  3618. }
  3619.  
  3620. void PauseEvent()
  3621. {
  3622.     if (pausing) {
  3623.     pausing = FALSE;
  3624.     ModeHighlight();
  3625.     if (gameMode == MachinePlaysWhite ||
  3626.         gameMode == MachinePlaysBlack) {
  3627.         StartClocks();
  3628.     } else {
  3629.         DisplayBothClocks();
  3630.     }
  3631.     if (gameMode == PlayFromGameFile &&
  3632.         !LoadGameTimerRunning() &&
  3633.         appData.timeDelay >= 0) {
  3634.         StartLoadGameTimer((long)(1000.0 * appData.timeDelay));
  3635.     }
  3636.     } else {
  3637.     switch (gameMode) {
  3638.       case EndOfGame:
  3639.       case EditPosition:
  3640.       default:
  3641.         return;
  3642.       case IcsObserving:
  3643.       case IcsPlayingWhite:
  3644.       case IcsPlayingBlack:
  3645.         pausing = TRUE;
  3646.         ModeHighlight();
  3647.         return;
  3648.       case PlayFromGameFile:
  3649.         (void) StopLoadGameTimer();
  3650.         pausing = TRUE;
  3651.         ModeHighlight();
  3652.         break;
  3653.       case BeginningOfGame:
  3654.         if (appData.icsActive) return;
  3655.         /* else fall through */
  3656.       case MachinePlaysWhite:
  3657.       case MachinePlaysBlack:
  3658.       case TwoMachinesPlay:
  3659.         if (forwardMostMove == 0)
  3660.           return;        /* don't pause if no one has moved */
  3661.         if ((gameMode == MachinePlaysWhite &&
  3662.          !WhiteOnMove(forwardMostMove)) ||
  3663.         (gameMode == MachinePlaysBlack &&
  3664.          WhiteOnMove(forwardMostMove))) {
  3665.         StopClocks();
  3666.         }
  3667.         pausing = TRUE;
  3668.         ModeHighlight();
  3669.         break;
  3670.     }
  3671.     }
  3672. }
  3673.  
  3674. void EditCommentEvent()
  3675. {
  3676.     EditCommentPopUp(currentMove, commentList[currentMove]);
  3677. }
  3678.  
  3679. void ReplaceComment(index, text)
  3680.      int index;
  3681.      char *text;
  3682. {
  3683.     int len;
  3684.  
  3685.     len = strlen(text);
  3686.  
  3687.     if (commentList[index] != NULL)
  3688.       free(commentList[index]);
  3689.  
  3690.     if (len == 0) {
  3691.     commentList[index] = NULL;
  3692.     return;
  3693.     }
  3694.  
  3695.     commentList[index] = (char *) malloc(len + 3);
  3696.     if (text[0] != '[' ||
  3697.     (text[len-1] != ']' && text[len-2] != ']')) {
  3698.     strcpy(commentList[index], "[");
  3699.     strcat(commentList[index], text);
  3700.     strcat(commentList[index], "]");
  3701.     } else {
  3702.     strcpy(commentList[index], text);
  3703.     }
  3704. }
  3705.  
  3706. void AppendComment(index, text)
  3707.      int index;
  3708.      char *text;
  3709. {
  3710.     int oldlen, len;
  3711.     char *old;
  3712.  
  3713.     len = strlen(text);
  3714.  
  3715.     if (len == 0) return;
  3716.  
  3717.     if (commentList[index] != NULL) {
  3718.     old = commentList[index];
  3719.     oldlen = strlen(old);
  3720.     commentList[index] = (char *) malloc(oldlen + len + 4);
  3721.     strcpy(commentList[index], old);
  3722.     free(old);
  3723.     if (commentList[index][oldlen - 1] != '\n')
  3724.       strcat(commentList[index], "\n");
  3725.     } else {
  3726.     commentList[index] = (char *) malloc(len + 3);
  3727.     commentList[index][0] = NULLCHAR;
  3728.     }
  3729.  
  3730.     if (text[0] != '[' ||
  3731.     (text[len-1] != ']' && text[len-2] != ']')) {
  3732.     strcat(commentList[index], "[");
  3733.     strcat(commentList[index], text);
  3734.     strcat(commentList[index], "]");
  3735.     } else {
  3736.     strcat(commentList[index], text);
  3737.     }
  3738. }
  3739.  
  3740. void SendToProgram(message, pr)
  3741.      char *message;
  3742.      ProcRef pr;
  3743. {
  3744.     int count, outCount, error;
  3745.     char *which;
  3746.     char buf[MSG_SIZ];
  3747.  
  3748.     if (pr == NULL) return;
  3749.     lastMsgPR = pr;
  3750.     which = (pr == firstProgramPR) ? "first" : "second";
  3751.     
  3752.     if (appData.debugMode)
  3753.       fprintf(debugFP, "Sending to %s: %s", which, message);
  3754.     
  3755.     count = strlen(message);
  3756.     outCount = OutputToProcess(pr, message, count, &error);
  3757.     if (outCount < count) {
  3758.     sprintf(buf, "Error writing to %s chess program", which);
  3759.     DisplayFatalError(buf, error);
  3760.     ExitEvent(1);
  3761.     }
  3762. }
  3763.  
  3764. void ReceiveFromProgram(isr, message, count, error)
  3765.      InputSourceRef isr;
  3766.      char *message;
  3767.      int count;
  3768.      int error;
  3769. {
  3770.     char *end_str, *name, *which;
  3771.  
  3772.     if (count <= 0) {
  3773.     if (isr == firstProgramISR) {
  3774.         which = "first";
  3775.         name = appData.firstChessProgram;
  3776.     } else if (isr == secondProgramISR) {
  3777.         which = "second";
  3778.         name = appData.secondChessProgram;
  3779.     } else {
  3780.         return;
  3781.     }
  3782.     if (count == 0) {
  3783.         sprintf(message, "Error: %s chess program (%s) exited unexpectedly",
  3784.             which, name);
  3785.         DisplayFatalError(message, 0);
  3786.     } else {
  3787.         sprintf(message,
  3788.             "Error reading from %s chess program (%s)",
  3789.             which, name);
  3790.         DisplayFatalError(message, error);
  3791.     }
  3792.     ShutdownChessPrograms(message);
  3793.     return;  /* don't actually exit */
  3794.     }
  3795.     
  3796.     if ((end_str = strchr(message, '\r')) != NULL)
  3797.       *end_str = NULLCHAR;
  3798.     if ((end_str = strchr(message, '\n')) != NULL)
  3799.       *end_str = NULLCHAR;
  3800.     
  3801.     if (appData.debugMode)
  3802.       fprintf(debugFP, "Received from %s: %s\n",
  3803.           isr == firstProgramISR ? "first" : "second", message);
  3804.     HandleMachineMove(message, isr);
  3805. }
  3806.  
  3807.  
  3808. void SendSearchDepth(pr)
  3809.      ProcRef pr;
  3810. {
  3811.     char message[MSG_SIZ];
  3812.     
  3813.     if (appData.searchDepth <= 0) return;
  3814.     
  3815.     sprintf(message, "depth\n%d\nhelp\n", appData.searchDepth);
  3816.     /* note kludge: "help" command forces gnuchessx to print
  3817.        out something that ends with a newline. */
  3818.     SendToProgram(message, pr);
  3819. }
  3820.  
  3821. void SendTimeRemaining(pr)
  3822.      ProcRef pr;
  3823. {
  3824.     char message[MSG_SIZ];
  3825.     long time;
  3826.  
  3827.     if (WhiteOnMove(forwardMostMove))
  3828.       time = whiteTimeRemaining;
  3829.     else
  3830.       time = blackTimeRemaining;
  3831.     
  3832.     if (time <= 0) time = 1000;
  3833.     
  3834.     sprintf(message, "time %d\n", time/10);
  3835.     SendToProgram(message, pr);
  3836. }
  3837.  
  3838.  
  3839. void DisplayMove(moveNumber)
  3840.      int moveNumber;
  3841. {
  3842.     char message[MSG_SIZ];
  3843.     
  3844.     if (moveNumber < 0) {
  3845.     if (moveNumber == forwardMostMove - 1)
  3846.       DisplayMessage(endMessage);
  3847.     else
  3848.       DisplayMessage("");
  3849.     } else {
  3850.     sprintf(message, "%d. %s%s  %s", moveNumber / 2 + 1,
  3851.         WhiteOnMove(moveNumber) ? "" : "... ",
  3852.         parseList[moveNumber],
  3853.         moveNumber == forwardMostMove - 1 ? endMessage : "");
  3854.     DisplayMessage(message);
  3855.     }
  3856. }
  3857.  
  3858. /*
  3859.  * This routine sends a ^C interrupt to gnuchess to awaken it
  3860.  * if it might be busy thinking on our time.  This normally isn't needed,
  3861.  * but is useful on systems where the FIONREAD ioctl doesn't work (such 
  3862.  * as ESIX), since on those systems the gnuchess feature that lets you 
  3863.  * interrupt its thinking just by typing a command does not work.
  3864.  *
  3865.  * In the future, similar code could be used to stop gnuchess and make
  3866.  * it move immediately when it is thinking about its own move; this could
  3867.  * be useful if we want to make Backward or ForceMoves work while gnuchess
  3868.  * is thinking. --t.mann
  3869.  */
  3870. void Attention(pr)
  3871.      ProcRef pr;
  3872. {
  3873. #if defined(ATTENTION) || defined(ESIX)
  3874.     if (appData.noChessProgram || (pr == NoProc)) return;
  3875.     switch (gameMode) {
  3876.       case MachinePlaysWhite:
  3877.       case MachinePlaysBlack:
  3878.       case TwoMachinesPlay:
  3879.     if (forwardMostMove > backwardMostMove + 1 && maybeThinking) {
  3880.         if (appData.debugMode)
  3881.           fprintf(debugFP, "Interrupting %s\n",
  3882.               pr == firstProgramPR ? "first" : "second");
  3883.         InterruptChildProcess(pr);
  3884.     }
  3885.     break;
  3886.     }
  3887. #endif /*ATTENTION*/
  3888. }
  3889.  
  3890. void CheckFlags()
  3891. {
  3892.     if (whiteTimeRemaining <= 0) {
  3893.     if (!whiteFlag) {
  3894.         whiteFlag = TRUE;
  3895.         if (appData.icsActive) {
  3896.         if (appData.autoCallFlag &&
  3897.             gameMode == IcsPlayingBlack && !blackFlag)
  3898.           SendToICS("flag\n");
  3899.         } else {
  3900.         if (blackFlag)
  3901.           DisplayTitle("Both flags have fallen");
  3902.         else
  3903.           DisplayTitle("White's flag has fallen");
  3904.         }
  3905.     }
  3906.     }
  3907.     if (blackTimeRemaining <= 0) {
  3908.     if (!blackFlag) {
  3909.         blackFlag = TRUE;
  3910.         if (appData.icsActive) {
  3911.         if (appData.autoCallFlag &&
  3912.             gameMode == IcsPlayingWhite && !whiteFlag)
  3913.           SendToICS("flag\n");
  3914.         } else {
  3915.         if (whiteFlag)
  3916.           DisplayTitle("Both flags have fallen");
  3917.         else
  3918.           DisplayTitle("Black's flag has fallen");
  3919.         }
  3920.     }
  3921.     }
  3922. }
  3923.  
  3924. void CheckTimeControl()
  3925. {
  3926.     if (!appData.clockMode || appData.icsActive ||
  3927.     gameMode == PlayFromGameFile || forwardMostMove == 0) return;
  3928.     /*
  3929.      * add time to clocks when time control is achieved
  3930.      */
  3931.     if ((forwardMostMove % (appData.movesPerSession * 2)) == 0) {
  3932.     whiteTimeRemaining += timeControl;
  3933.     blackTimeRemaining += timeControl;
  3934.     }
  3935. }
  3936.  
  3937. void DisplayBothClocks()
  3938. {
  3939.     DisplayWhiteClock(whiteTimeRemaining, WhiteOnMove(currentMove));
  3940.     DisplayBlackClock(blackTimeRemaining, !WhiteOnMove(currentMove));
  3941. }
  3942.  
  3943.  
  3944. /* Timekeeping seems to be a portability nightmare.  I think everyone
  3945.    has ftime(), but I'm really not sure, so I'm including some ifdefs
  3946.    to use other calls if you don't.  Clocks will be less accurate if
  3947.    you have neither ftime nor gettimeofday.
  3948. */
  3949.  
  3950. /* A point in time */
  3951. typedef struct {
  3952.     long sec;  /* Assuming this is >= 32 bits */
  3953.     int ms;    /* Assuming this is >= 16 bits */
  3954. } TimeMark;
  3955.  
  3956. /* Get the current time as a TimeMark */
  3957. void GetTimeMark(tm)
  3958.      TimeMark *tm;
  3959. {
  3960. #ifdef HAS_GETTIMEOFDAY
  3961.  
  3962. #if !defined(ESIX)
  3963. #include <sys/time.h>
  3964. #endif
  3965.     struct timeval timeVal;
  3966.     struct timezone timeZone;
  3967.  
  3968.     gettimeofday(&timeVal, &timeZone);
  3969.     tm->sec = (long) timeVal.tv_sec; 
  3970.     tm->ms = (int) (timeVal.tv_usec / 1000L);
  3971.  
  3972. #else /*!HAS_GETTIMEOFDAY*/
  3973. #ifdef HAS_FTIME
  3974.  
  3975. #include <sys/timeb.h>
  3976.     struct timeb timeB;
  3977.  
  3978.     ftime(&timeB);
  3979.     tm->sec = (long) timeB.time;
  3980.     tm->ms = (int) timeB.millitm;
  3981.  
  3982. #else /*!HAS_FTIME && !HAS_GETTIMEOFDAY*/
  3983.  
  3984.     tm->sec = (long) time(NULL);
  3985.     tm->ms = 0;
  3986.  
  3987. #endif
  3988. #endif
  3989. }
  3990.  
  3991. /* Return the difference in milliseconds between two
  3992.    time marks.  We assume the difference will fit in a long!
  3993. */
  3994. long SubtractTimeMarks(tm2, tm1)
  3995.      TimeMark *tm2, *tm1;
  3996. {
  3997.     return 1000L*(tm2->sec - tm1->sec) +
  3998.            (long) (tm2->ms - tm1->ms);
  3999. }
  4000.  
  4001.  
  4002. /*
  4003.  * Code to manage the game clocks.
  4004.  *
  4005.  * In tournament play, black starts the clock and then white makes a move.
  4006.  * We give the human user a slight advantage if he is playing white---the
  4007.  * clocks don't run until he makes his first move, so it takes zero time.
  4008.  * Also, we doesn't account for network lag, so we could get
  4009.  * out of sync with GNU Chess's clock -- but then, referees are always right.
  4010.  */
  4011.  
  4012. static TimeMark tickStartTM;
  4013. static long intendedTickLength;
  4014.  
  4015. long NextTickLength(timeRemaining)
  4016.      long timeRemaining;
  4017. {
  4018.     long nominalTickLength, nextTickLength;
  4019.  
  4020.     if (timeRemaining > 0L && timeRemaining <= 1000L)
  4021.       nominalTickLength = 100L;
  4022.     else
  4023.       nominalTickLength = 1000L;
  4024.     nextTickLength = timeRemaining % nominalTickLength;
  4025.     if (nextTickLength <= 0) nextTickLength += nominalTickLength;
  4026.  
  4027.     return nextTickLength;
  4028. }
  4029.  
  4030. /* Stop clocks and reset to a fresh time control */
  4031. void ResetClocks() 
  4032. {
  4033.     (void) StopClockTimer();
  4034.     whiteTimeRemaining = timeControl;
  4035.     blackTimeRemaining = timeControl;
  4036.     if (whiteFlag || blackFlag) {
  4037.     DisplayTitle("");
  4038.     whiteFlag = blackFlag = FALSE;
  4039.     }
  4040.     DisplayBothClocks();
  4041. }
  4042.     
  4043. #define FUDGE 25 /* 25ms = 1/40 sec; should be plenty even for 50 Hz clocks */
  4044.  
  4045. /* Decrement running clock by amount of time that has passed */
  4046. void DecrementClocks()
  4047. {
  4048.     long timeRemaining;
  4049.     long lastTickLength, fudge;
  4050.     TimeMark now;
  4051.  
  4052.     if (!appData.clockMode) return;
  4053.     
  4054.     GetTimeMark(&now);
  4055.  
  4056.     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
  4057.  
  4058.     /* Fudge if we woke up a little too soon */
  4059.     fudge = intendedTickLength - lastTickLength;
  4060.     if (fudge < 0 || fudge > FUDGE) fudge = 0;
  4061.  
  4062. /*!!*/if (appData.debugMode && fudge) fprintf(debugFP, "fudging %d   ", fudge);
  4063.  
  4064.     if (WhiteOnMove(forwardMostMove)) {
  4065.     timeRemaining = whiteTimeRemaining -= lastTickLength;
  4066.     DisplayWhiteClock(whiteTimeRemaining - fudge,
  4067.               WhiteOnMove(currentMove));
  4068.     } else {
  4069.     timeRemaining = blackTimeRemaining -= lastTickLength;
  4070.     DisplayBlackClock(blackTimeRemaining - fudge,
  4071.               !WhiteOnMove(currentMove));
  4072.     }
  4073.     
  4074.     CheckFlags();
  4075.     
  4076.     tickStartTM = now;
  4077.     intendedTickLength = NextTickLength(timeRemaining - fudge) + fudge;
  4078.     StartClockTimer(intendedTickLength);
  4079. }
  4080.  
  4081.     
  4082. /* A player has just moved, so stop the previously running
  4083.    clock and (if in clock mode) start the other one.
  4084.    We redisplay both clocks in case we're in ICS mode, because
  4085.    ICS gives us an update to both clocks after every move.
  4086. */
  4087. void SwitchClocks()
  4088. {
  4089.     long lastTickLength;
  4090.     TimeMark now;
  4091.  
  4092.     GetTimeMark(&now);
  4093.  
  4094.     if (StopClockTimer() && appData.clockMode) {
  4095.     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
  4096.     if (WhiteOnMove(forwardMostMove)) {
  4097.         whiteTimeRemaining -= lastTickLength;
  4098.     } else {
  4099.         blackTimeRemaining -= lastTickLength;
  4100.     }
  4101.     CheckFlags();
  4102.     }
  4103.     CheckTimeControl();
  4104.     DisplayBothClocks();
  4105.  
  4106.     if (!appData.clockMode) return;
  4107.  
  4108.     switch (gameMode) {
  4109.       case MachinePlaysBlack:
  4110.       case MachinePlaysWhite:
  4111.       case BeginningOfGame:
  4112.     if (pausing) return;
  4113.     break;
  4114.  
  4115.       case ForceMoves:
  4116.       case PlayFromGameFile:
  4117.     return;
  4118.  
  4119.       default:
  4120.     break;
  4121.     }
  4122.  
  4123.     tickStartTM = now;
  4124.     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
  4125.       whiteTimeRemaining : blackTimeRemaining);
  4126.     StartClockTimer(intendedTickLength);
  4127. }
  4128.     
  4129.  
  4130. /* Stop both clocks */
  4131. void StopClocks()
  4132. {    
  4133.     long lastTickLength;
  4134.     TimeMark now;
  4135.  
  4136.     if (!StopClockTimer()) return;
  4137.     if (!appData.clockMode) return;
  4138.  
  4139.     GetTimeMark(&now);
  4140.  
  4141.     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
  4142.     if (WhiteOnMove(forwardMostMove)) {
  4143.     whiteTimeRemaining -= lastTickLength;
  4144.     DisplayWhiteClock(whiteTimeRemaining, WhiteOnMove(currentMove));
  4145.     } else {
  4146.     blackTimeRemaining -= lastTickLength;
  4147.     DisplayBlackClock(blackTimeRemaining, !WhiteOnMove(currentMove));
  4148.     }
  4149.     CheckFlags();
  4150. }
  4151.     
  4152. /* Start clock of player on move.  Time may have been reset, so
  4153.    if clock is already running, stop and restart it. */
  4154. void StartClocks()
  4155. {
  4156.     (void) StopClockTimer(); /* in case it was running already */
  4157.     DisplayBothClocks();
  4158.  
  4159.     if (!appData.clockMode) return;
  4160.  
  4161.     GetTimeMark(&tickStartTM);
  4162.     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
  4163.       whiteTimeRemaining : blackTimeRemaining);
  4164.     StartClockTimer(intendedTickLength);
  4165. }
  4166.  
  4167. char *TimeString(ms)
  4168.      long ms;
  4169. {
  4170.     long second, minute, hour, day;
  4171.     char *sign = "";
  4172.     static char buf[32];
  4173.     
  4174.     if (ms > 0 && ms <= 900) {
  4175.     /* convert milliseconds to tenths, rounding up */
  4176.     sprintf(buf, " 0.%1d ", (ms+99L)/100L);
  4177.     return buf;
  4178.     }
  4179.  
  4180.     /* convert milliseconds to seconds, rounding up */
  4181.     /* use floating point to avoid strangeness of integer division
  4182.        with negative dividends on many machines */
  4183.     second = (long) floor(((double) (ms + 999L)) / 1000.0);
  4184.  
  4185.     if (second < 0) {
  4186.     sign = "-";
  4187.     second = -second;
  4188.     }
  4189.     
  4190.     day = second / (60 * 60 * 24);
  4191.     second = second % (60 * 60 * 24);
  4192.     hour = second / (60 * 60);
  4193.     second = second % (60 * 60);
  4194.     minute = second / 60;
  4195.     second = second % 60;
  4196.     
  4197.     if (day > 0)
  4198.       sprintf(buf, " %s%d:%02d:%02d:%02d ", sign, day, hour, minute, second);
  4199.     else if (hour > 0)
  4200.       sprintf(buf, " %s%d:%02d:%02d ", sign, hour, minute, second);
  4201.     else
  4202.       sprintf(buf, " %s%2d:%02d ", sign, minute, second);
  4203.     
  4204.     return buf;
  4205. }
  4206.  
  4207.  
  4208. /*
  4209.  * This is necessary because some C libraries aren't ANSI C compliant yet.
  4210.  */
  4211. char *StrStr(string, match)
  4212.      char *string, *match;
  4213. {
  4214.     int i, length;
  4215.     
  4216.     length = strlen(match);
  4217.     
  4218.     for (i = strlen(string) - length; i >= 0; i--, string++)
  4219.       if (!strncmp(match, string, (size_t) length))
  4220.     return string;
  4221.     
  4222.     return NULL;
  4223. }
  4224.  
  4225. int StrCaseCmp(s1, s2)
  4226.      char *s1, *s2;
  4227. {
  4228.     char c1, c2;
  4229.     
  4230.     for (;;) {
  4231.     c1 = ToLower(*s1++);
  4232.     c2 = ToLower(*s2++);
  4233.     if (c1 > c2) return 1;
  4234.     if (c1 < c2) return -1;
  4235.     if (c1 == NULLCHAR) return 0;
  4236.     }
  4237. }
  4238.  
  4239.  
  4240. int ToLower(c)
  4241.      int c;
  4242. {
  4243.     return isupper(c) ? tolower(c) : c;
  4244. }
  4245.  
  4246.  
  4247. int ToUpper(c)
  4248.      int c;
  4249. {
  4250.     return islower(c) ? toupper(c) : c;
  4251. }
  4252.  
  4253.  
  4254.