home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / xboard-2.1.pl11 / xboard.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-14  |  167.6 KB  |  6,031 lines
  1. /*
  2.  * XBoard -- an Xt/Athena user interface for GNU Chess
  3.  *
  4.  * Original authors:  Dan Sears and Chris Sears.
  5.  * Enhancements (Version 2.0 and following):  Tim Mann.
  6.  * Thanks to John Chanak for the initial implementation of ICS mode.
  7.  *
  8.  * XBoard borrows its colors, icon and piece bitmaps from XChess
  9.  * which was written and is copyrighted by Wayne Christopher.
  10.  *
  11.  * Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts.
  12.  * Enhancements Copyright 1992 Free Software Foundation, Inc.
  13.  *
  14.  * The following terms apply to Digital Equipment Corporation's copyright
  15.  * interest in XBoard:
  16.  * ------------------------------------------------------------------------
  17.  * All Rights Reserved
  18.  *
  19.  * Permission to use, copy, modify, and distribute this software and its
  20.  * documentation for any purpose and without fee is hereby granted,
  21.  * provided that the above copyright notice appear in all copies and that
  22.  * both that copyright notice and this permission notice appear in
  23.  * supporting documentation, and that the name of Digital not be
  24.  * used in advertising or publicity pertaining to distribution of the
  25.  * software without specific, written prior permission.
  26.  *
  27.  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  28.  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  29.  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  30.  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  31.  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  32.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  33.  * SOFTWARE.
  34.  * ------------------------------------------------------------------------
  35.  *
  36.  * This file is part of XBOARD.
  37.  *
  38.  * XBOARD is distributed in the hope that it will be useful, but WITHOUT ANY
  39.  * WARRANTY.  No author or distributor accepts responsibility to anyone for
  40.  * the consequences of using it or for whether it serves any particular
  41.  * purpose or works at all, unless he says so in writing.  Refer to the XBOARD
  42.  * General Public License for full details.
  43.  *
  44.  * Everyone is granted permission to copy, modify and redistribute XBOARD, but
  45.  * only under the conditions described in the XBOARD General Public License. A
  46.  * copy of this license is supposed to have been given to you along with
  47.  * XBOARD so you can know your rights and responsibilities.  It should be in a
  48.  * file named COPYING.  Among other things, the copyright notice and this
  49.  * notice must be preserved on all copies.
  50.  * ------------------------------------------------------------------------
  51.  *
  52.  * See the file ChangeLog for a detailed revision history.
  53.  */
  54.  
  55. #define VERSION "2.1"
  56.  
  57. #include <stdio.h>
  58. #include <ctype.h>
  59. #include <signal.h>
  60. #include <errno.h>
  61. #include <sys/ioctl.h>
  62. #include <sys/types.h>
  63. #include <sys/socket.h>
  64. #include <netinet/in.h>
  65. #include <netdb.h>
  66. #include <time.h>
  67. #ifdef HAS_GETTIMEOFDAY
  68. #ifndef ESIX
  69. #include <sys/time.h>
  70. #endif
  71. #endif
  72. #ifdef    __STDC__
  73. #ifndef ESIX
  74. #include <stdlib.h>
  75. #endif
  76. #endif
  77. #if defined(SYSTEM_FIVE) || defined(SYSV)
  78. #include <sys/types.h>
  79. #include <sys/stat.h>
  80. #ifdef AIXV3
  81. #include <fcntl.h>
  82. #else
  83. #include <sys/fcntl.h>
  84. #endif /*AIXV3*/
  85. #ifdef SVR4
  86. #include <stropts.h>
  87. #ifdef sun
  88. #include <sys/systeminfo.h>
  89. #endif
  90. #endif
  91. #endif
  92. #if defined(__STDC__) || defined(SYSTEM_FIVE) || defined(SYSV) || defined(sun)
  93. #include <string.h>
  94. #else
  95. #include <strings.h>
  96. #endif
  97. #include <pwd.h>
  98. #include <X11/Intrinsic.h>
  99. #include <X11/StringDefs.h>
  100. #include <X11/Shell.h>
  101. #include <X11/Xaw/Dialog.h>
  102. #include <X11/Xaw/Form.h>
  103. #include <X11/Xaw/List.h>
  104. #include <X11/Xaw/Label.h>
  105. #include <X11/Xaw/SimpleMenu.h>
  106. #include <X11/Xaw/SmeBSB.h>
  107. #include <X11/Xaw/SmeLine.h>
  108. #include <X11/cursorfont.h>
  109. #include "xboard.h"
  110. #include "patchlevel.h"
  111.  
  112. #include "bitmaps/s_p.bm"
  113. #include "bitmaps/s_r.bm"
  114. #include "bitmaps/s_n.bm"
  115. #include "bitmaps/s_b.bm"
  116. #include "bitmaps/s_q.bm"
  117. #include "bitmaps/s_k.bm"
  118.  
  119. #include "bitmaps/ol_p.bm"
  120. #include "bitmaps/ol_r.bm"
  121. #include "bitmaps/ol_n.bm"
  122. #include "bitmaps/ol_b.bm"
  123. #include "bitmaps/ol_q.bm"
  124. #include "bitmaps/ol_k.bm"
  125.  
  126. #include "bitmaps/sm_s_p.bm"
  127. #include "bitmaps/sm_s_r.bm"
  128. #include "bitmaps/sm_s_n.bm"
  129. #include "bitmaps/sm_s_b.bm"
  130. #include "bitmaps/sm_s_q.bm"
  131. #include "bitmaps/sm_s_k.bm"
  132.  
  133. #include "bitmaps/sm_ol_p.bm"
  134. #include "bitmaps/sm_ol_r.bm"
  135. #include "bitmaps/sm_ol_n.bm"
  136. #include "bitmaps/sm_ol_b.bm"
  137. #include "bitmaps/sm_ol_q.bm"
  138. #include "bitmaps/sm_ol_k.bm"
  139.  
  140. #include "bitmaps/xs_s_p.bm"
  141. #include "bitmaps/xs_s_r.bm"
  142. #include "bitmaps/xs_s_n.bm"
  143. #include "bitmaps/xs_s_b.bm"
  144. #include "bitmaps/xs_s_q.bm"
  145. #include "bitmaps/xs_s_k.bm"
  146.  
  147. #include "bitmaps/xs_ol_p.bm"
  148. #include "bitmaps/xs_ol_r.bm"
  149. #include "bitmaps/xs_ol_n.bm"
  150. #include "bitmaps/xs_ol_b.bm"
  151. #include "bitmaps/xs_ol_q.bm"
  152. #include "bitmaps/xs_ol_k.bm"
  153.  
  154. #include "bitmaps/icon.bm"
  155.  
  156. int establish P((char *host, int port));
  157. void read_from_player P((caddr_t client_data, int *file_num, XtInputId *id));
  158. void read_from_ics P((caddr_t client_data, int *file_num, XtInputId *id));
  159. void main P((int argc, char **argv));
  160. void CreateGCs P((void));
  161. void CreatePieces P((void));
  162. void CreatePieceMenus P((void));
  163. char *FindFont P((char *pattern, int targetPxlSize));
  164. void PieceMenuPopup P((Widget w, XEvent *event,
  165.                String *params, Cardinal *num_params));
  166. static void PieceMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
  167. static void SetWhiteToPlay P((Widget w, XEvent *event,
  168.                   String *prms, Cardinal *nprms));
  169. static void SetBlackToPlay P((Widget w, XEvent *event,
  170.                   String *prms, Cardinal *nprms));
  171. void ReadBitmap P((String name, Pixmap *pm, char large_bits[],
  172.            char medium_bits[], char small_bits[]));
  173. void CreateGrid P((void));
  174. int EventToSquare P((int x));
  175. ChessSquare CharToPiece P((int c));
  176. char PieceToChar P((ChessSquare p));
  177. ChessSquare PromoPiece P((ChessMove move_type));
  178. ChessMove CoordsToAlgebraic P((int fromX, int fromY, int toX, int toY,
  179.                    int promoChar, int currentBoardIndex,
  180.                    char out[MOVE_LEN]));
  181. void DrawSquare P((int row, int column, ChessSquare piece));
  182. void EventProc P((Widget widget, caddr_t unused, XEvent *event));
  183. void DrawPosition P((Widget w, XEvent *event,
  184.              String *prms, Cardinal *nprms));
  185. void InitPosition P((int/*Boolean*/ redraw));
  186. void CopyBoard P((Board to, Board from));
  187. Boolean CompareBoards P((Board board1, Board board2));
  188. void SendCurrentBoard P((FILE *fp));
  189. void SendBoard P((FILE *fp, Board board));
  190. void HandleUserMove P((Widget w, XEvent *event,
  191.                String *prms, Cardinal *nprms));
  192. void FinishUserMove P((ChessMove move_type, int to_x, int to_y));
  193. void HandleMachineMove P((char *message, FILE *fp));
  194. void LoadGameLoop P((void));
  195. Boolean LoadGameOneMove P((void));
  196. void ApplyMove P((ChessMove *move_type, int from_x, int from_y,
  197.           int to_x, int to_y, Board board));
  198. void MakeMove P((ChessMove *move_type, int from_x, int from_y,
  199.          int to_x, int to_y));
  200. void InitChessProgram P((char *host_name, char *program_name, int *pid,
  201.              FILE **to, FILE **from, XtIntervalId *xid,
  202.              int *sendTime));
  203. void GameEnds P((char *message));
  204. void ShutdownChessPrograms P((char *message));
  205. void CommentPopUp P((char *label));
  206. void CommentPopDown P((void));
  207. void FileNamePopUp P((char *label, char *def,
  208.               Boolean (*proc)(char *name)));
  209. void FileNameCallback P((Widget w, XtPointer client_data,
  210.              XtPointer call_data));
  211. void FileNameAction P((Widget w, XEvent *event,
  212.                String *prms, Cardinal *nprms));
  213. void PromotionPopUp P((ChessSquare piece, int to_x, int to_y));
  214. void PromotionCallback P((Widget w, XtPointer client_data,
  215.               XtPointer call_data));
  216. void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));
  217. void ModeHighlight P((void));
  218. void LoadGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  219. void QuitProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  220. void DrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  221. void DeclineDrawProc P((Widget w, XEvent *event,
  222.             String *prms, Cardinal *nprms));
  223. void ResignProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  224. void CallFlagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  225. Boolean LoadGame P((char *name));
  226. void MachineBlackProc P((Widget w, XEvent *event, String *prms,
  227.              Cardinal *nprms));
  228. void ForwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  229. void Reset P((int/*Boolean*/ redraw));
  230. void ResetProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  231. Boolean LoadPosition P((char *name));
  232. void LoadPositionProc P((Widget w, XEvent *event,
  233.              String *prms, Cardinal *nprms));
  234. void MachineWhiteProc P((Widget w, XEvent *event,
  235.              String *prms, Cardinal *nprms));
  236. void BackwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  237. void FlipViewProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  238. Boolean SaveGame P((char *name));
  239. void SaveGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  240. void SwitchProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  241. void EditPositionProc P((Widget w, XEvent *event,
  242.              String *prms, Cardinal *nprms));
  243. void EditPositionDone P((void));
  244. void ForceProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  245. void HintProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  246. void NothingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  247. Boolean SavePosition P((char *name));
  248. void SavePositionProc P((Widget w, XEvent *event,
  249.              String *prms, Cardinal *nprms));
  250. void TwoMachinesProc P((Widget w, XEvent *event, String *prms,
  251.             Cardinal *nprms));
  252. void PauseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  253. void Iconify P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
  254. void PrintOpponents P((FILE *fp));
  255. void PrintPosition P((FILE *fp, int move));
  256. void SendToProgram P((char *message, FILE *fp));
  257. void ReceiveFromProgram P((FILE *fp, int *source, XtInputId *id));
  258. void SendSearchDepth P((FILE *fp));
  259. void SendTimeRemaining P((FILE *fp));
  260. void DisplayMessage P((char *message));
  261. void DisplayMove P((int moveNumber));
  262. void DisplayTitle P((char *title));
  263. void Attention P((int pid));
  264. void DisplayClocks P((int clock_mode));
  265. void DisplayTimerLabel P((Widget w, char *color, long timer));
  266. char *TimeString P((long tm));
  267. void Usage P((void));
  268. char *StrStr P((char *string, char *match));
  269. int StrCaseCmp P((char *s1, char *s2));
  270. int ToLower P((int c));
  271. int ToUpper P((int c));
  272. #if defined(SYSTEM_FIVE) || defined(SYSV)
  273. char *PseudoTTY P((int *ptyv));
  274. #else
  275. void CatchPipeSignal P((int dummy));
  276. #endif
  277. extern int yylex P((void));
  278. extern int yynewfile P((void));
  279. extern ChessMove yylexstr P((int boardIndex, char *s, char **next));
  280. extern ChessMove LegalityTest P((int whiteOnMove, Board board,
  281.                  int rf, int ff, int rt, int ft,
  282.                  int promoChar));
  283. void ParseMachineMove P((char *machine_move, int move_num,
  284.              ChessMove *move_type, int *from_x, int *from_y,
  285.              int *to_x, int *to_y, char *promo_char));
  286. void ParseGameHistory P((char *game));
  287. void ParseBoard8 P((char *string));
  288.  
  289. /*
  290. * XBoard depends on Xt R4 or higher
  291. */
  292. int xtVersion = XtSpecificationRelease;
  293.  
  294. int xScreen;
  295. Display *xDisplay;
  296. Window xBoardWindow;
  297. GC lightSquareGC, darkSquareGC, lineGC, wdPieceGC, wlPieceGC,
  298.   bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC;
  299. Pixmap solidPawnBitmap, solidRookBitmap, solidKnightBitmap,
  300.   solidBishopBitmap, solidQueenBitmap, solidKingBitmap,
  301.   outlinePawnBitmap, outlineRookBitmap, outlineKnightBitmap,
  302.   outlineBishopBitmap, outlineQueenBitmap, outlineKingBitmap, iconPixmap;
  303. Widget shellWidget, formWidget, boardWidget, commandsWidget, messageWidget,
  304.   whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[6], 
  305.   commentShell, promotionShell, whitePieceMenu, blackPieceMenu;
  306. XSegment gridSegments[(BOARD_SIZE + 1) * 2];
  307. XtIntervalId firstProgramXID = 0, secondProgramXID = 0,
  308.   readGameXID = 0, timerXID = 0;
  309. Font mainFontID, coordFontID;
  310. XFontStruct *mainFontStruct, *coordFontStruct;
  311. XtAppContext appContext;
  312. Boolean (*fileProc) P((char *name));
  313. Position commentX = -1, commentY = -1;
  314.  
  315. FILE *fromFirstProgFP, *toFirstProgFP, *fromSecondProgFP,
  316.   *toSecondProgFP, *gameFileFP, *lastMsgFP;
  317. int currentMove = 0, forwardMostMove = 0, backwardMostMove = 0,
  318.   firstProgramPID = 0, secondProgramPID = 0, telnetPID = 0,
  319.   squareSize = LARGE_SQUARE_SIZE, fromX = -1,
  320.   fromY = -1, firstMove = True, flipView = False,
  321.   commentUp = False, filenameUp = False,
  322.   blackPlaysFirst = False, startedFromSetupPosition = False,
  323.   promotionUp = False, searchTime = 0, pmFromX = -1, pmFromY = -1,
  324.   whiteFlag = False, blackFlag = False, maybeThinking = False, 
  325.   ics_input = -1, ics_output = -1, ics_user_moved = 0, ics_gamenum = -1,
  326.   ics_getting_history = False;
  327. int firstSendTime = 2, secondSendTime = 2;  /* 0=don't, 1=do, 2=test first*/
  328. IcsMode ics_mode = IcsIdle;
  329. Pixel timerForegroundPixel, timerBackgroundPixel;
  330. MatchMode matchMode = MatchFalse;
  331. GameMode gameMode = BeginningOfGame, lastGameMode = BeginningOfGame,
  332.   pausePreviousMode = BeginningOfGame;
  333. BoardSize boardSize = Large;
  334. char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2],
  335.   ptyname[24], *chessDir, *programName, ics_black[32], ics_white[32],
  336.   endMessage[MOVE_LEN * 4];
  337.  
  338. long whiteTimeRemaining, blackTimeRemaining, timeControl;
  339. long timeRemaining[2][MAX_MOVES];
  340. extern char currentMoveString[];
  341. extern char yytext[];
  342. extern int yyboardindex;
  343.      
  344. Board boards[MAX_MOVES], initialPosition = {
  345.     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
  346.     WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
  347.     { WhitePawn, WhitePawn, WhitePawn, WhitePawn,
  348.     WhitePawn, WhitePawn, WhitePawn, WhitePawn },
  349.     { EmptySquare, EmptySquare, EmptySquare, EmptySquare,
  350.     EmptySquare, EmptySquare, EmptySquare, EmptySquare },
  351.     { EmptySquare, EmptySquare, EmptySquare, EmptySquare,
  352.     EmptySquare, EmptySquare, EmptySquare, EmptySquare },
  353.     { EmptySquare, EmptySquare, EmptySquare, EmptySquare,
  354.     EmptySquare, EmptySquare, EmptySquare, EmptySquare },
  355.     { EmptySquare, EmptySquare, EmptySquare, EmptySquare,
  356.     EmptySquare, EmptySquare, EmptySquare, EmptySquare },
  357.     { BlackPawn, BlackPawn, BlackPawn, BlackPawn,
  358.     BlackPawn, BlackPawn, BlackPawn, BlackPawn },
  359.     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
  360.     BlackKing, BlackBishop, BlackKnight, BlackRook }
  361. };
  362.      
  363. String gnuButtonStrings[] = {
  364.     "Quit",          "Machine Black", "Load Game",     "Forward",
  365.     "Reset",         "Machine White", "Save Game",     "Backward",
  366.     "Flip View",     "Force Moves",   "Load Position", "Pause",
  367.     "Edit Position", "Two Machines",  "Save Position", "Hint"
  368.   };
  369. /* must be in same order as buttonStrings! */
  370. XtActionProc gnuButtonProcs[] = {
  371.     QuitProc,         MachineBlackProc, LoadGameProc,     ForwardProc,
  372.     ResetProc,        MachineWhiteProc, SaveGameProc,     BackwardProc,
  373.     FlipViewProc,     ForceProc,        LoadPositionProc, PauseProc,
  374.     EditPositionProc, TwoMachinesProc,  SavePositionProc, HintProc,  
  375.     NULL
  376.   };
  377.  
  378. String icsButtonStrings[] = {
  379.     "Quit",          "Call Flag",    "Load Game",     "Forward",       
  380.     "Reset",         "Draw",         "Save Game",     "Backward",
  381.     "Flip View",     "Decline Draw", "Load Position", "Pause",
  382.     "Edit Position", "Resign",       "Save Position", ""
  383.   };
  384. /* must be in same order as icsButtonStrings! */
  385. XtActionProc icsButtonProcs[] = {
  386.     QuitProc,         CallFlagProc,    LoadGameProc,     ForwardProc,
  387.     ResetProc,        DrawProc,        SaveGameProc,     BackwardProc,
  388.     FlipViewProc,     DeclineDrawProc, LoadPositionProc, PauseProc,
  389.     EditPositionProc, ResignProc,      SavePositionProc, NothingProc,
  390.     NULL
  391.   };
  392.  
  393. String *buttonStrings;
  394. XtActionProc *buttonProcs;
  395. int buttonCount;
  396.  
  397. #define PIECE_MENU_SIZE 10
  398. String pieceMenuStrings[PIECE_MENU_SIZE] = {
  399.     "----", "Pawn", "Knight", "Bishop", "Rook", "Queen", "King",
  400.     "----", "Empty square", "Clear board"
  401.   };
  402. /* must be in same order as PieceMenuStrings! */
  403. ChessSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] = {
  404.     { (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
  405.     WhiteRook, WhiteQueen, WhiteKing,
  406.     (ChessSquare) 0, EmptySquare, ClearBoard },
  407.     { (ChessSquare) 0, BlackPawn, BlackKnight, BlackBishop,
  408.     BlackRook, BlackQueen, BlackKing,
  409.     (ChessSquare) 0, EmptySquare, ClearBoard },
  410. };
  411.  
  412. Arg shellArgs[] = {
  413.     { XtNwidth, 0 },
  414.     { XtNheight, 0 },
  415.     { XtNminWidth, 0 },
  416.     { XtNminHeight, 0 },
  417.     { XtNmaxWidth, 0 },
  418.     { XtNmaxHeight, 0 }
  419. };
  420.  
  421. Arg boardArgs[] = {
  422.     { XtNborderWidth, 0 },
  423.     { XtNwidth, LINE_GAP + BOARD_SIZE * (LARGE_SQUARE_SIZE + LINE_GAP) },
  424.     { XtNheight, LINE_GAP + BOARD_SIZE * (LARGE_SQUARE_SIZE + LINE_GAP) }
  425. };
  426.  
  427. Arg messageArgs[] = {
  428.     { XtNborderWidth, 0 },
  429.     { XtNjustify, (XtArgVal) XtJustifyLeft },
  430.     { XtNlabel, (XtArgVal) "starting..." }
  431. };
  432.  
  433. Arg timerArgs[] = {
  434.     { XtNborderWidth, 0 },
  435.     { XtNjustify, (XtArgVal) XtJustifyLeft }
  436. };
  437.  
  438. Arg titleArgs[] = {
  439.     { XtNborderWidth, 0 },
  440.     { XtNjustify, (XtArgVal) XtJustifyLeft }
  441. };
  442.  
  443. typedef struct {
  444.     Pixel whitePieceColor;
  445.     Pixel blackPieceColor;
  446.     Pixel lightSquareColor;
  447.     Pixel darkSquareColor;
  448.     int movesPerSession;
  449.     String initString;
  450.     String whiteString;
  451.     String blackString;
  452.     String firstChessProgram;
  453.     String secondChessProgram;
  454.     Boolean noChessProgram;
  455.     String firstHost;
  456.     String secondHost;
  457.     String solidPawnBitmap;
  458.     String solidRookBitmap;
  459.     String solidBishopBitmap;
  460.     String solidKnightBitmap;
  461.     String solidQueenBitmap;
  462.     String solidKingBitmap;
  463.     String outlinePawnBitmap;
  464.     String outlineRookBitmap;
  465.     String outlineBishopBitmap;
  466.     String outlineKnightBitmap;
  467.     String outlineQueenBitmap;
  468.     String outlineKingBitmap;
  469.     String remoteShell;
  470.     float timeDelay;
  471.     String timeControl;
  472.     Boolean icsActive;
  473.     String icsHost;
  474.     int icsPort;
  475.     Boolean useTelnet;
  476.     String telnetProgram;
  477.     String gateway;
  478.     String loadGameFile;
  479.     String saveGameFile;
  480.     Boolean autoSaveGames;
  481.     String loadPositionFile;
  482.     String savePositionFile;
  483.     String matchMode;
  484.     Boolean monoMode;
  485.     Boolean debugMode;
  486.     Boolean clockMode;
  487.     String boardSize;
  488.     Boolean Iconic;
  489.     String searchTime;
  490.     int searchDepth;
  491.     Boolean showCoords;
  492.     String mainFont;
  493.     String coordFont;
  494.     Boolean ringBellAfterMoves;
  495.     Boolean autoCallFlag;
  496.     int borderXoffset;
  497.     int borderYoffset;
  498. } AppData, *AppDataPtr;
  499.  
  500. AppData appData;
  501.  
  502. XtResource clientResources[] = {
  503.     { "whitePieceColor", "WhitePieceColor", XtRPixel, sizeof(Pixel),
  504.     XtOffset(AppDataPtr, whitePieceColor), XtRString,
  505.     WHITE_PIECE_COLOR },
  506.     { "blackPieceColor", "BlackPieceColor", XtRPixel, sizeof(Pixel),
  507.     XtOffset(AppDataPtr, blackPieceColor), XtRString,
  508.     BLACK_PIECE_COLOR },
  509.     { "lightSquareColor", "LightSquareColor", XtRPixel,
  510.     sizeof(Pixel), XtOffset(AppDataPtr, lightSquareColor),
  511.     XtRString, LIGHT_SQUARE_COLOR }, 
  512.     { "darkSquareColor", "DarkSquareColor", XtRPixel, sizeof(Pixel),
  513.     XtOffset(AppDataPtr, darkSquareColor), XtRString,
  514.     DARK_SQUARE_COLOR },
  515.     { "movesPerSession", "movesPerSession", XtRInt, sizeof(int),
  516.     XtOffset(AppDataPtr, movesPerSession), XtRImmediate,
  517.     (XtPointer) MOVES_PER_SESSION },
  518.     { "initString", "initString", XtRString, sizeof(String),
  519.     XtOffset(AppDataPtr, initString), XtRString, INIT_STRING },
  520.     { "whiteString", "whiteString", XtRString, sizeof(String),
  521.     XtOffset(AppDataPtr, whiteString), XtRString, WHITE_STRING },
  522.     { "blackString", "blackString", XtRString, sizeof(String),
  523.     XtOffset(AppDataPtr, blackString), XtRString, BLACK_STRING },
  524.     { "firstChessProgram", "firstChessProgram", XtRString,
  525.     sizeof(String), XtOffset(AppDataPtr, firstChessProgram),
  526.     XtRString, FIRST_CHESS_PROGRAM },
  527.     { "secondChessProgram", "secondChessProgram", XtRString,
  528.     sizeof(String), XtOffset(AppDataPtr, secondChessProgram),
  529.     XtRString, SECOND_CHESS_PROGRAM },
  530.     { "noChessProgram", "noChessProgram", XtRBoolean,
  531.     sizeof(Boolean), XtOffset(AppDataPtr, noChessProgram),
  532.     XtRImmediate, (XtPointer) False },
  533.     { "firstHost", "firstHost", XtRString, sizeof(String),
  534.     XtOffset(AppDataPtr, firstHost), XtRString, FIRST_HOST },
  535.     { "secondHost", "secondHost", XtRString, sizeof(String),
  536.     XtOffset(AppDataPtr, secondHost), XtRString, SECOND_HOST },
  537.     { "solidPawnBitmap", "solidPawnBitmap", XtRString,
  538.     sizeof(String), XtOffset(AppDataPtr, solidPawnBitmap),
  539.     XtRString, "" },
  540.     { "solidRookBitmap", "solidRookBitmap", XtRString,
  541.     sizeof(String), XtOffset(AppDataPtr, solidRookBitmap),
  542.     XtRString, "" },
  543.     { "solidKnightBitmap", "solidKnightBitmap", XtRString,
  544.     sizeof(String), XtOffset(AppDataPtr, solidKnightBitmap),
  545.     XtRString, "" },
  546.     { "solidBishopBitmap", "solidBishopBitmap", XtRString,
  547.     sizeof(String), XtOffset(AppDataPtr, solidBishopBitmap),
  548.     XtRString, "" },
  549.     { "solidQueenBitmap", "solidQueenBitmap", XtRString,
  550.     sizeof(String), XtOffset(AppDataPtr, solidQueenBitmap),
  551.     XtRString, "" },
  552.     { "solidKingBitmap", "solidKingBitmap", XtRString,
  553.     sizeof(String), XtOffset(AppDataPtr, solidKingBitmap),
  554.     XtRString, "" },
  555.     { "outlinePawnBitmap", "outlinePawnBitmap", XtRString,
  556.     sizeof(String), XtOffset(AppDataPtr, outlinePawnBitmap),
  557.     XtRString, "" },
  558.     { "outlineRookBitmap", "outlineRookBitmap", XtRString,
  559.     sizeof(String), XtOffset(AppDataPtr, outlineRookBitmap),
  560.     XtRString, "" },
  561.     { "outlineKnightBitmap", "outlineKnightBitmap", XtRString,
  562.     sizeof(String), XtOffset(AppDataPtr, outlineKnightBitmap),
  563.     XtRString, "" },
  564.     { "outlineBishopBitmap", "outlineBishopBitmap", XtRString,
  565.     sizeof(String), XtOffset(AppDataPtr, outlineBishopBitmap),
  566.     XtRString, "" },
  567.     { "outlineQueenBitmap", "outlineQueenBitmap", XtRString,
  568.     sizeof(String), XtOffset(AppDataPtr, outlineQueenBitmap),
  569.     XtRString, "" },
  570.     { "outlineKingBitmap", "outlineKingBitmap", XtRString,
  571.     sizeof(String), XtOffset(AppDataPtr, outlineKingBitmap),
  572.     XtRString, "" },
  573.     { "remoteShell", "remoteShell", XtRString, sizeof(String),
  574.     XtOffset(AppDataPtr, remoteShell), XtRString, "rsh" },
  575.     { "timeDelay", "timeDelay", XtRFloat, sizeof(float),
  576.     XtOffset(AppDataPtr, timeDelay), XtRString,
  577.     (XtPointer) TIME_DELAY },
  578.     { "timeControl", "timeControl", XtRString, sizeof(String),
  579.     XtOffset(AppDataPtr, timeControl), XtRString,
  580.     (XtPointer) TIME_CONTROL },
  581.     { "internetChessServerMode", "internetChessServerMode",
  582.     XtRBoolean, sizeof(Boolean),
  583.     XtOffset(AppDataPtr, icsActive), XtRImmediate,
  584.     (XtPointer) False },
  585.     { "internetChessServerHost", "internetChessServerHost",
  586.     XtRString, sizeof(String),
  587.     XtOffset(AppDataPtr, icsHost),
  588.     XtRString, (XtPointer) ICS_HOST },
  589.     { "internetChessServerPort", "internetChessServerPort",
  590.     XtRInt, sizeof(int),
  591.     XtOffset(AppDataPtr, icsPort), XtRImmediate,
  592.     (XtPointer) ICS_PORT },
  593.     { "useTelnet", "useTelnet", XtRBoolean, sizeof(Boolean),
  594.     XtOffset(AppDataPtr, useTelnet), XtRImmediate,
  595.     (XtPointer) False },
  596.     { "telnetProgram", "telnetProgram", XtRString, sizeof(String),
  597.     XtOffset(AppDataPtr, telnetProgram), XtRString, "telnet" },
  598.     { "gateway", "gateway", XtRString, sizeof(String),
  599.     XtOffset(AppDataPtr, gateway), XtRString, "" },
  600.     { "loadGameFile", "loadGameFile", XtRString, sizeof(String),
  601.     XtOffset(AppDataPtr, loadGameFile), XtRString, "" },
  602.     { "saveGameFile", "saveGameFile", XtRString, sizeof(String),
  603.     XtOffset(AppDataPtr, saveGameFile), XtRString, "" },
  604.     { "autoSaveGames", "autoSaveGames", XtRBoolean,
  605.     sizeof(Boolean), XtOffset(AppDataPtr, autoSaveGames),
  606.     XtRImmediate, (XtPointer) False },
  607.     { "loadPositionFile", "loadPositionFile", XtRString,
  608.     sizeof(String), XtOffset(AppDataPtr, loadPositionFile),
  609.     XtRString, "" },
  610.     { "savePositionFile", "savePositionFile", XtRString,
  611.     sizeof(String), XtOffset(AppDataPtr, savePositionFile),
  612.     XtRString, "" },
  613.     { "matchMode", "matchMode", XtRString, sizeof(String),
  614.     XtOffset(AppDataPtr, matchMode), XtRString, MATCH_MODE },
  615.     { "monoMode", "monoMode", XtRBoolean, sizeof(Boolean),
  616.     XtOffset(AppDataPtr, monoMode), XtRImmediate,
  617.     (XtPointer) False },
  618.     { "debugMode", "debugMode", XtRBoolean, sizeof(Boolean),
  619.     XtOffset(AppDataPtr, debugMode), XtRImmediate,
  620.     (XtPointer) False },
  621.     { "Iconic", "Iconic", XtRBoolean, sizeof(Boolean),
  622.     XtOffset(AppDataPtr, Iconic), XtRImmediate,
  623.     (XtPointer) False },
  624.     { "clockMode", "clockMode", XtRBoolean, sizeof(Boolean),
  625.     XtOffset(AppDataPtr, clockMode), XtRImmediate,
  626.     (XtPointer) True },
  627.     { "autoCallFlag", "autoCallFlag", XtRBoolean,
  628.     sizeof(Boolean), XtOffset(AppDataPtr, autoCallFlag),
  629.     XtRImmediate, (XtPointer) False },
  630.     { "boardSize", "boardSize", XtRString, sizeof(String),
  631.     XtOffset(AppDataPtr, boardSize), XtRString, DEFAULT_SIZE },
  632.     { "searchTime", "searchTime", XtRString, sizeof(String),
  633.     XtOffset(AppDataPtr, searchTime), XtRString,
  634.     (XtPointer) "" },
  635.     { "searchDepth", "searchDepth", XtRInt, sizeof(int),
  636.     XtOffset(AppDataPtr, searchDepth), XtRImmediate, 
  637.     (XtPointer) 0 },
  638.     { "showCoords", "showCoords", XtRBoolean, sizeof(Boolean),
  639.     XtOffset(AppDataPtr, showCoords), XtRImmediate,
  640.     (XtPointer) False },
  641.     { "mainFont", "mainFont", XtRString, sizeof(String),
  642.     XtOffset(AppDataPtr, mainFont), XtRString, MAIN_FONT },
  643.     { "coordFont", "coordFont", XtRString, sizeof(String),
  644.     XtOffset(AppDataPtr, coordFont), XtRString, COORD_FONT },
  645.     { "ringBellAfterMoves", "ringBellAfterMoves",
  646.     XtRBoolean, sizeof(Boolean),
  647.     XtOffset(AppDataPtr, ringBellAfterMoves),
  648.     XtRImmediate, (XtPointer) False    },
  649.     { "borderXoffset", "borderXoffset", XtRInt, sizeof(int),
  650.     XtOffset(AppDataPtr, borderXoffset), XtRImmediate,
  651.     (XtPointer) BORDER_X_OFFSET },
  652.     { "borderYoffset", "borderYOffset", XtRInt, sizeof(int),
  653.     XtOffset(AppDataPtr, borderYoffset), XtRImmediate,
  654.     (XtPointer) BORDER_Y_OFFSET },
  655. };
  656.  
  657. Pixmap *pieceToSolid[] = {
  658.     &solidPawnBitmap, &solidRookBitmap, &solidKnightBitmap,
  659.     &solidBishopBitmap, &solidQueenBitmap, &solidKingBitmap,
  660.     &solidPawnBitmap, &solidRookBitmap, &solidKnightBitmap,
  661.     &solidBishopBitmap, &solidQueenBitmap, &solidKingBitmap
  662.   };
  663.  
  664. Pixmap *pieceToOutline[] = {
  665.     &outlinePawnBitmap, &outlineRookBitmap, &outlineKnightBitmap,
  666.     &outlineBishopBitmap, &outlineQueenBitmap, &outlineKingBitmap,
  667.     &outlinePawnBitmap, &outlineRookBitmap, &outlineKnightBitmap,
  668.     &outlineBishopBitmap, &outlineQueenBitmap, &outlineKingBitmap
  669.   };
  670.  
  671. char pieceToChar[] = {
  672.     'P', 'R', 'N', 'B', 'Q', 'K',
  673.     'p', 'r', 'n', 'b', 'q', 'k', '.'
  674.   };
  675.  
  676. XrmOptionDescRec shellOptions[] = {
  677.     { "-movesPerSession", "movesPerSession", XrmoptionSepArg, NULL },
  678.     { "-mps", "movesPerSession", XrmoptionSepArg, NULL },
  679.     { "-internetChessServerMode", "internetChessServerMode",
  680.     XrmoptionSepArg, NULL },
  681.     { "-ics", "internetChessServerMode", XrmoptionSepArg, NULL },
  682.     { "-internetChessServerPort", "internetChessServerPort",
  683.     XrmoptionSepArg, NULL },
  684.     { "-icsport", "internetChessServerPort", XrmoptionSepArg, NULL },
  685.     { "-internetChessServerHost", "internetChessServerHost",
  686.     XrmoptionSepArg, NULL },
  687.     { "-icshost", "internetChessServerHost", XrmoptionSepArg, NULL },
  688.     { "-firstChessProgram", "firstChessProgram", XrmoptionSepArg, NULL },
  689.     { "-fcp", "firstChessProgram", XrmoptionSepArg, NULL },
  690.     { "-secondChessProgram", "secondChessProgram", XrmoptionSepArg, NULL },
  691.     { "-scp", "secondChessProgram", XrmoptionSepArg, NULL },
  692.     { "-noChessProgram", "noChessProgram", XrmoptionSepArg, NULL },
  693.     { "-ncp", "noChessProgram", XrmoptionSepArg, NULL },
  694.     { "-firstHost", "firstHost", XrmoptionSepArg, NULL },
  695.     { "-fh", "firstHost", XrmoptionSepArg, NULL },
  696.     { "-secondHost", "secondHost", XrmoptionSepArg, NULL },
  697.     { "-sh", "secondHost", XrmoptionSepArg, NULL },
  698.     { "-remoteShell", "remoteShell", XrmoptionSepArg, NULL },
  699.     { "-rsh", "remoteShell", XrmoptionSepArg, NULL },
  700.     { "-timeDelay", "timeDelay", XrmoptionSepArg, NULL },
  701.     { "-td", "timeDelay", XrmoptionSepArg, NULL },
  702.     { "-timeControl", "timeControl", XrmoptionSepArg, NULL },
  703.     { "-tc", "timeControl", XrmoptionSepArg, NULL },
  704.     { "-loadGameFile", "loadGameFile", XrmoptionSepArg, NULL },
  705.     { "-lgf", "loadGameFile", XrmoptionSepArg, NULL },
  706.     { "-saveGameFile", "saveGameFile", XrmoptionSepArg, NULL },
  707.     { "-sgf", "saveGameFile", XrmoptionSepArg, NULL },
  708.     { "-autoSaveGames", "autoSaveGames", XrmoptionSepArg, NULL },
  709.     { "-autosave", "autoSaveGames", XrmoptionSepArg, NULL },
  710.     { "-loadPositionFile", "loadPositionFile", XrmoptionSepArg, NULL },
  711.     { "-lpf", "loadPositionFile", XrmoptionSepArg, NULL },
  712.     { "-savePositionFile", "savePositionFile", XrmoptionSepArg, NULL },
  713.     { "-spf", "savePositionFile", XrmoptionSepArg, NULL },
  714.     { "-matchMode", "matchMode", XrmoptionSepArg, NULL },
  715.     { "-mm", "matchMode", XrmoptionSepArg, NULL },
  716.     { "-monoMode", "monoMode", XrmoptionSepArg, NULL },
  717.     { "-mono", "monoMode", XrmoptionSepArg, NULL },
  718.     { "-debugMode", "debugMode", XrmoptionSepArg, NULL },
  719.     { "-debug", "debugMode", XrmoptionSepArg, NULL },
  720.     { "-clockMode", "clockMode", XrmoptionSepArg, NULL },
  721.     { "-clock", "clockMode", XrmoptionSepArg, NULL },
  722.     { "-autoCallFlag", "autoCallFlags", XrmoptionSepArg, NULL },
  723.     { "-autoflag", "autoCallFlag", XrmoptionSepArg, NULL },
  724.     { "-boardSize", "boardSize", XrmoptionSepArg, NULL },
  725.     { "-size", "boardSize", XrmoptionSepArg, NULL },
  726.     { "-searchTime", "searchTime", XrmoptionSepArg, NULL },
  727.     { "-st", "searchTime", XrmoptionSepArg, NULL },
  728.     { "-searchDepth", "searchDepth", XrmoptionSepArg, NULL },
  729.     { "-sd", "searchDepth", XrmoptionSepArg, NULL },
  730.     { "-showCoords", "showCoords", XrmoptionSepArg, NULL },
  731.     { "-coords", "showCoords", XrmoptionSepArg, NULL },
  732.     { "-bell", "ringBellAfterMoves", XrmoptionSepArg, NULL },
  733.     { "-ringBellAfterMoves", "ringBellAfterMoves", XrmoptionSepArg, NULL },
  734.     { "-iconic", "Iconic", XrmoptionNoArg, "True" }
  735. };
  736.  
  737. XtActionsRec boardActions[] = {
  738.     { "DrawPosition", DrawPosition },
  739.     { "HandleUserMove", HandleUserMove },
  740.     { "ResetProc", ResetProc },
  741.     { "LoadGameProc", LoadGameProc },
  742.     { "QuitProc", QuitProc },
  743.     { "ForwardProc", ForwardProc },
  744.     { "BackwardProc", BackwardProc },
  745.     { "PauseProc", PauseProc },
  746.     { "Iconify", Iconify },
  747.     { "FileNameAction", FileNameAction },
  748.     { "PieceMenuPopup", PieceMenuPopup },
  749.     { "SetWhiteToPlay", SetWhiteToPlay },
  750.     { "SetBlackToPlay", SetBlackToPlay }
  751. };
  752.      
  753. char translationsTable[] =
  754.   "<Expose>: DrawPosition() \n \
  755.    <Btn1Down>: HandleUserMove() \n \
  756.    <Btn1Up>: HandleUserMove() \n \
  757.    <Btn2Down>: XawPositionSimpleMenu(menuW) PieceMenuPopup(menuW) \n \
  758.    <Btn3Down>: XawPositionSimpleMenu(menuB) PieceMenuPopup(menuB) \n \
  759.    <Key>r: ResetProc() \n \
  760.    <Key>R: ResetProc() \n \
  761.    <Key>g: LoadGameProc() \n \
  762.    <Key>G: LoadGameProc() \n \
  763.    <Key>q: QuitProc() \n \
  764.    <Key>Q: QuitProc() \n \
  765.    <Message>WM_PROTOCOLS: QuitProc() \n \
  766.    <Key>f: ForwardProc() \n \
  767.    <Key>F: ForwardProc() \n \
  768.    <Key>b: BackwardProc() \n \
  769.    <Key>B: BackwardProc() \n \
  770.    <Key>p: PauseProc() \n \
  771.    <Key>P: PauseProc() \n \
  772.    <Key>i: Iconify() \n \
  773.    <Key>I: Iconify() \n \
  774.    <Key>c: Iconify() \n \
  775.    <Key>C: Iconify() \n";
  776.      
  777. char whiteTranslations[] = "<BtnDown>: SetWhiteToPlay()\n";
  778. char blackTranslations[] = "<BtnDown>: SetBlackToPlay()\n";
  779.      
  780. String xboardResources[] = {
  781.     DEFAULT_FONT,
  782.     "*Dialog*value.translations: #override \\n <Key>Return: FileNameAction()",
  783.     NULL
  784.   };
  785.      
  786. void main(argc, argv)
  787.      int argc;
  788.      char **argv;
  789. {
  790.     int ok, i, mainFontPxlSize, coordFontPxlSize;
  791.     int min, sec, matched;
  792.     XSetWindowAttributes window_attributes;
  793.     char buf[MSG_SIZ];
  794.     Arg args[10];
  795.     Dimension timerWidth, boardWidth, commandsWidth, w, h;
  796.     XFontStruct *labelFontStruct;
  797.     
  798.     setbuf(stdout, NULL);
  799.     setbuf(stderr, NULL);
  800.     
  801.     programName = strrchr(argv[0], '/');
  802.     if (programName == NULL)
  803.       programName = argv[0];
  804.     else
  805.       programName++;
  806.     
  807.     shellWidget =
  808.       XtAppInitialize(&appContext, "XBoard", shellOptions,
  809.               XtNumber(shellOptions), &argc, argv,
  810.               xboardResources, NULL, 0);
  811.     if (argc > 1)
  812.       Usage();
  813.     
  814.     if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {
  815.     chessDir = ".";
  816.     } else {
  817.     if (chdir(chessDir) != 0) {
  818.         fprintf(stderr, "%s: can't cd to CHESSDIR: ", programName);
  819.         perror(chessDir);
  820.         exit(1);
  821.     }
  822.     }
  823.     
  824.     XtGetApplicationResources(shellWidget, &appData, clientResources,
  825.                   XtNumber(clientResources), NULL, 0);
  826.     
  827.     /*
  828.      * Determine matchMode state -- poor man's resource converter
  829.      */
  830.     if (StrCaseCmp(appData.matchMode, "Init") == 0)
  831.       matchMode = MatchInit;
  832.     else if (StrCaseCmp(appData.matchMode, "Position") == 0)
  833.       matchMode = MatchPosition;
  834.     else if (StrCaseCmp(appData.matchMode, "Opening") == 0)
  835.       matchMode = MatchOpening;
  836.     else if (StrCaseCmp(appData.matchMode, "False") == 0)
  837.       matchMode = MatchFalse;
  838.     else {
  839.     fprintf(stderr, "%s: bad matchMode option %s\n",
  840.         programName, appData.matchMode);
  841.     Usage();
  842.     }
  843.     
  844.     /*
  845.      * Parse internet chess server status
  846.      */
  847.     if (appData.icsActive) {
  848.     ok = establish(appData.icsHost,
  849.                (unsigned short)appData.icsPort);
  850.     if (ok == -1) {
  851.         fprintf(stderr,
  852.             "%s: could not connect to host %s, port %d: ",
  853.             programName, appData.icsHost, appData.icsPort);
  854.         perror("");
  855.         exit(1);
  856.     }
  857.     appData.noChessProgram = True;
  858.     buttonStrings = icsButtonStrings;
  859.     buttonProcs = icsButtonProcs;
  860.     buttonCount = XtNumber(icsButtonStrings);
  861.     } else {
  862.     buttonStrings = gnuButtonStrings;
  863.     buttonProcs = gnuButtonProcs;
  864.     buttonCount = XtNumber(gnuButtonStrings);
  865.     }
  866.     
  867.     /*
  868.      * Parse timeControl resource
  869.      */
  870.     matched = sscanf(appData.timeControl, "%d:%d", &min, &sec);
  871.     if (matched == 1) {
  872.     timeControl = min * 60 * 1000;
  873.     } else if (matched == 2) {
  874.     timeControl = (min * 60 + sec) * 1000;
  875.     } else {
  876.     fprintf(stderr, "%s: bad timeControl option %s\n",
  877.         programName, appData.timeControl);
  878.     Usage();
  879.     }
  880.     if (appData.icsActive) timeControl = 0;
  881.     
  882.     /*
  883.      * Parse searchTime resource
  884.      */
  885.     if (*appData.searchTime != NULLCHAR) {
  886.     matched = sscanf(appData.searchTime, "%d:%d", &min, &sec);
  887.     if (matched == 1) {
  888.         searchTime = min * 60;
  889.     } else if (matched == 2) {
  890.         searchTime = min * 60 + sec;
  891.     } else {
  892.         fprintf(stderr, "%s: bad searchTime option %s\n",
  893.             programName, appData.searchTime);
  894.         Usage();
  895.     }
  896.     }
  897.     
  898.     /*
  899.      * Determine boardSize
  900.      */
  901.     if (StrCaseCmp(appData.boardSize, "Large") == 0)
  902.       boardSize = Large;
  903.     else if (StrCaseCmp(appData.boardSize, "Medium") == 0)
  904.       boardSize = Medium;
  905.     else if (StrCaseCmp(appData.boardSize, "Small") == 0)
  906.       boardSize = Small;
  907.     else {
  908.     fprintf(stderr, "%s: bad boardSize option %s\n",
  909.         programName, appData.boardSize);
  910.     Usage();
  911.     }
  912.     xDisplay = XtDisplay(shellWidget);
  913.     xScreen = DefaultScreen(xDisplay);
  914.     if (((DisplayWidth(xDisplay, xScreen) < 800) ||
  915.      (DisplayHeight(xDisplay, xScreen) < 800))
  916.     && (boardSize == Large)) {
  917.     boardSize = Medium;
  918.     }
  919.     switch (boardSize) {
  920.       case Small:
  921.     squareSize = SMALL_SQUARE_SIZE;
  922.     mainFontPxlSize = 11;
  923.     coordFontPxlSize = 10;
  924.     break;
  925.       case Medium:
  926.     squareSize = MEDIUM_SQUARE_SIZE;
  927.     mainFontPxlSize = 17;
  928.     coordFontPxlSize = 12;
  929.     break;
  930.       case Large:
  931.     squareSize = LARGE_SQUARE_SIZE;
  932.     mainFontPxlSize = 17;
  933.     coordFontPxlSize = 14;
  934.     break;
  935.     }
  936.     boardWidth = LINE_GAP + BOARD_SIZE * (squareSize + LINE_GAP);
  937.     XtSetArg(boardArgs[1], XtNwidth, boardWidth);
  938.     XtSetArg(boardArgs[2], XtNheight,
  939.          LINE_GAP + BOARD_SIZE * (squareSize + LINE_GAP));
  940.     
  941.     /*
  942.      * Determine what fonts to use.
  943.      */
  944.     appData.mainFont = FindFont(appData.mainFont, mainFontPxlSize);
  945.     mainFontID = XLoadFont(xDisplay, appData.mainFont);
  946.     mainFontStruct = XQueryFont(xDisplay, mainFontID);
  947.     appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);
  948.     coordFontID = XLoadFont(xDisplay, appData.coordFont);
  949.     coordFontStruct = XQueryFont(xDisplay, coordFontID);
  950.  
  951.     if ((*appData.searchTime != NULLCHAR) || (appData.searchDepth > 0)
  952.     || appData.noChessProgram)
  953.       appData.clockMode = False;
  954.     if (appData.icsActive) appData.clockMode = True;
  955.     
  956.     /*
  957.      * Detect if there are not enough colors are available and adapt.
  958.      */
  959.     if (DefaultDepth(xDisplay, xScreen) <= 2)
  960.       appData.monoMode = True;
  961.     
  962.     /*
  963.      * widget hierarchy
  964.      */
  965.     formWidget =
  966.       XtCreateManagedWidget("form", formWidgetClass, shellWidget, NULL, 0);
  967.     
  968.     widgetList[0] = whiteTimerWidget =
  969.       XtCreateWidget("white time:", labelWidgetClass,
  970.              formWidget, timerArgs, XtNumber(timerArgs));
  971.     XtSetArg(args[0], XtNfont, mainFontStruct);
  972.     XtSetValues(whiteTimerWidget, args, 1);
  973.     
  974.     widgetList[1] = blackTimerWidget =
  975.       XtCreateWidget("black time:", labelWidgetClass,
  976.              formWidget, timerArgs, XtNumber(timerArgs));
  977.     XtSetArg(args[0], XtNfont, mainFontStruct);
  978.     XtSetValues(blackTimerWidget, args, 1);
  979.     
  980.     widgetList[2] = titleWidget =
  981.       XtCreateWidget("", labelWidgetClass,
  982.              formWidget, titleArgs, XtNumber(titleArgs));
  983.     XtSetArg(args[0], XtNfont, mainFontStruct);
  984.     XtSetValues(titleWidget, args, 1);
  985.     
  986.     widgetList[3] = messageWidget =
  987.       XtCreateWidget("message", labelWidgetClass, formWidget,
  988.              messageArgs, XtNumber(messageArgs));
  989.     XtSetArg(args[0], XtNfont, mainFontStruct);
  990.     XtSetValues(messageWidget, args, 1);
  991.     
  992.     i = 0;
  993.     XtSetArg(args[i], XtNborderWidth, 0);                  i++;
  994.     XtSetArg(args[i], XtNdefaultColumns, 4);               i++;
  995.     XtSetArg(args[i], XtNforceColumns, True);              i++;
  996.     XtSetArg(args[i], XtNcolumnSpacing, 12);               i++;
  997.     XtSetArg(args[i], XtNlist, (XtArgVal) buttonStrings);  i++;
  998.     XtSetArg(args[i], XtNnumberStrings, buttonCount);      i++;
  999.     XtSetArg(args[i], XtNfont, mainFontStruct);            i++;
  1000.     widgetList[4] = commandsWidget =
  1001.       XtCreateWidget("commands", listWidgetClass, formWidget, args, i);
  1002.     
  1003.     widgetList[5] = boardWidget =
  1004.       XtCreateWidget("board", widgetClass, formWidget, boardArgs,
  1005.              XtNumber(boardArgs));
  1006.     
  1007.     XtManageChildren(widgetList, XtNumber(widgetList));
  1008.     
  1009.     /*
  1010.      * Calculate the width of the timer labels.
  1011.      */
  1012.     XtSetArg(args[0], XtNfont, &labelFontStruct);
  1013.     XtGetValues(whiteTimerWidget, args, 1);
  1014.     if (appData.clockMode) {
  1015.     if (timeControl == 0) 
  1016.       sprintf(buf, "White: %s ", TimeString(2 * 60 * 60 * 1000));
  1017.     else
  1018.       sprintf(buf, "White: %s ", TimeString(-timeControl));
  1019.     timerWidth = XTextWidth(labelFontStruct, buf, strlen(buf) - 1);
  1020.     } else {
  1021.     timerWidth = XTextWidth(labelFontStruct, "White  ", 7);
  1022.     }
  1023.     XtSetArg(args[0], XtNwidth, timerWidth);
  1024.     XtSetValues(whiteTimerWidget, args, 1);
  1025.     XtSetValues(blackTimerWidget, args, 1);
  1026.     
  1027.     XtSetArg(args[0], XtNbackground, &timerForegroundPixel);
  1028.     XtSetArg(args[1], XtNforeground, &timerBackgroundPixel);
  1029.     XtGetValues(whiteTimerWidget, args, 2);
  1030.     
  1031.     /*
  1032.      * Calculate the width of the title and message labels.
  1033.      */
  1034.     XtSetArg(args[0], XtNwidth, &commandsWidth);
  1035.     XtGetValues(commandsWidget, args, 1);
  1036.     w = (commandsWidth > boardWidth) ? commandsWidth : boardWidth;
  1037.     XtSetArg(args[0], XtNwidth, w - timerWidth*2 - 12);
  1038.     XtSetValues(titleWidget, args, 1);
  1039.     XtSetArg(args[0], XtNwidth, w - 8);
  1040.     XtSetValues(messageWidget, args, 1);
  1041.     
  1042.     /*
  1043.      * formWidget uses these constraints but they are stored
  1044.      * in the children.
  1045.      */
  1046.     XtSetArg(args[0], XtNfromHoriz, whiteTimerWidget);
  1047.     XtSetValues(blackTimerWidget, args, 1);
  1048.     XtSetArg(args[0], XtNfromHoriz, blackTimerWidget);
  1049.     XtSetValues(titleWidget, args, 1);
  1050.     XtSetArg(args[0], XtNfromVert, whiteTimerWidget);
  1051.     XtSetValues(messageWidget, args, 1);
  1052.     XtSetArg(args[0], XtNfromVert, messageWidget);
  1053.     XtSetValues(commandsWidget, args, 1);
  1054.     XtSetArg(args[0], XtNfromVert, commandsWidget);
  1055.     XtSetValues(boardWidget, args, 1);
  1056.     
  1057.     if (appData.icsActive) {
  1058.     XtAppAddInput(appContext, ics_input,
  1059.               (XtPointer) (XtInputExceptMask|XtInputReadMask),
  1060.               (XtInputCallbackProc) read_from_ics,
  1061.               (XtPointer) NULL);
  1062.     XtAppAddInput(appContext, fileno(stdin),
  1063.               (XtPointer) XtInputReadMask,
  1064.               (XtInputCallbackProc) read_from_player,
  1065.               (XtPointer) NULL);
  1066.     } 
  1067.     
  1068.     XtRealizeWidget(shellWidget);
  1069.     
  1070.     xBoardWindow = XtWindow(boardWidget);
  1071.     
  1072.     /*
  1073.      * Create an icon.
  1074.      */
  1075.     iconPixmap = XCreateBitmapFromData(xDisplay, XtWindow(shellWidget),
  1076.                        icon_bits, icon_width, icon_height);
  1077.     XtSetArg(args[0], XtNiconPixmap, iconPixmap);
  1078.     XtSetValues(shellWidget, args, 1);
  1079.     
  1080.     /*
  1081.      * Create a cursor for the board widget.
  1082.      */
  1083.     window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);
  1084.     XChangeWindowAttributes(xDisplay, xBoardWindow,
  1085.                 CWCursor, &window_attributes);
  1086.     
  1087.     /*
  1088.      * Inhibit shell resizing.
  1089.      */
  1090.     shellArgs[0].value = (XtArgVal) &w;
  1091.     shellArgs[1].value = (XtArgVal) &h;
  1092.     XtGetValues(shellWidget, shellArgs, 2);
  1093.     shellArgs[4].value = shellArgs[2].value = w;
  1094.     shellArgs[5].value = shellArgs[3].value = h;
  1095.     XtSetValues(shellWidget, &shellArgs[2], 4);
  1096.     
  1097.     CreateGCs();
  1098.     CreateGrid();
  1099.     CreatePieces();
  1100.     CreatePieceMenus();
  1101.     
  1102.     XtAddCallback(commandsWidget, XtNcallback, SelectCommand, NULL);
  1103.     XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
  1104.     
  1105.     XtSetArg(args[0], XtNtranslations,
  1106.          XtParseTranslationTable(translationsTable));
  1107.     XtSetValues(boardWidget, &args[0], 1);
  1108.     XtSetArg(args[0], XtNtranslations,
  1109.          XtParseTranslationTable(whiteTranslations));
  1110.     XtSetValues(whiteTimerWidget, &args[0], 1);
  1111.     XtSetArg(args[0], XtNtranslations,
  1112.          XtParseTranslationTable(blackTranslations));
  1113.     XtSetValues(blackTimerWidget, &args[0], 1);
  1114.     
  1115.     XtAddEventHandler(boardWidget, ExposureMask | ButtonPressMask
  1116.               | ButtonReleaseMask | Button1MotionMask | KeyPressMask,
  1117.               False, (XtEventHandler) EventProc, NULL);
  1118.     
  1119.     sprintf(buf, "xboard version %s, patchlevel %d", VERSION, PATCHLEVEL);
  1120.     
  1121.     /*
  1122.      * If there is to be a machine match, set it up.
  1123.      */
  1124.     if (matchMode != MatchFalse){
  1125.     if (appData.noChessProgram) {
  1126.         fprintf(stderr,
  1127.             "%s: can't have a match with no chess programs!\n",
  1128.             programName);
  1129.         exit(1);
  1130.     }
  1131.     DisplayMessage(buf);
  1132.     TwoMachinesProc(NULL, NULL, NULL, NULL);
  1133.     }
  1134.     else {
  1135.     Reset(True);
  1136.     DisplayMessage(buf);
  1137.     if (*appData.loadGameFile != NULLCHAR)
  1138.       LoadGame(appData.loadGameFile);
  1139.     else if (*appData.loadPositionFile != NULLCHAR)
  1140.       LoadPosition(appData.loadPositionFile);
  1141.     }
  1142.     
  1143.     XtAppMainLoop(appContext);
  1144. }
  1145.  
  1146. /*
  1147.  * Establish will establish a contact to a remote host.port.
  1148.  * Returns 0 if okay, -1 if not.
  1149.  */
  1150. int establish(host, port)
  1151.      char *host;
  1152.      int port;
  1153. {
  1154.     int s;
  1155.     char str[100];
  1156.     int to_prog[2], from_prog[2];
  1157.     struct sockaddr_in sa;
  1158.     struct hostent     *hp;
  1159.     unsigned short uport;
  1160. #if defined(SYSTEM_FIVE) || defined(SYSV)
  1161.     char *pty_name;
  1162. #endif
  1163.     
  1164.     if (appData.useTelnet || (*appData.gateway != NULLCHAR)) {
  1165. #if defined(SYSTEM_FIVE) || defined(SYSV)
  1166.     if ((pty_name = PseudoTTY(&to_prog[1])) == NULL) {
  1167.         fprintf(stderr, "%s: can't open pseudo-tty: ", programName);
  1168.         perror("");
  1169.         exit(1);
  1170.     }
  1171.     from_prog[0] = to_prog[1];
  1172.     to_prog[0] = from_prog[1] = open(pty_name, O_RDWR, 0);
  1173. #ifdef SVR4
  1174.     if (ioctl (to_prog[0], I_PUSH, "ptem") == -1 ||
  1175.         ioctl (to_prog[0], I_PUSH, "ldterm") == -1 ||
  1176.         ioctl (to_prog[0], I_PUSH, "ttcompat") == -1) {
  1177.         fprintf(stderr, "%s: can't ioctl pseudo-tty: ", programName);
  1178.         perror("");
  1179.         exit(1);
  1180.     }
  1181. #endif
  1182. #else
  1183.     pipe(to_prog);
  1184.     pipe(from_prog);
  1185. #endif
  1186.     if ((telnetPID = fork()) == 0) {
  1187.         dup2(to_prog[0], 0);
  1188.         dup2(from_prog[1], 1);
  1189.         close(to_prog[0]);
  1190.         close(to_prog[1]);
  1191.         close(from_prog[0]);
  1192.         close(from_prog[1]);
  1193.         dup2(1, fileno(stderr)); /* force stderr to the pipe */
  1194.         
  1195.         uport = (unsigned short) port;
  1196.         sprintf(str, "%d", uport);
  1197.         if (*appData.gateway != NULLCHAR) {
  1198.         execlp(appData.remoteShell, appData.remoteShell,
  1199.                appData.gateway, appData.telnetProgram,
  1200.                host, str, (char *) NULL);
  1201.         } else {
  1202.         execlp(appData.telnetProgram, appData.telnetProgram,
  1203.                host, str, (char *) NULL);
  1204.         }
  1205.         perror(appData.telnetProgram);
  1206.         exit(1);
  1207.     }
  1208.     close(to_prog[0]);
  1209.     close(from_prog[1]);
  1210.     ics_input = from_prog[0];
  1211.     ics_output = to_prog[1];
  1212.     } else {
  1213. #ifdef SVR4
  1214.         memset((char *) &sa, (int)0, sizeof(struct sockaddr_in));
  1215. #else                /*!SVR4*/
  1216.         bzero((char *) &sa, sizeof(struct sockaddr_in));
  1217. #endif
  1218.     if (!(hp = gethostbyname(host))) {
  1219.         int b0, b1, b2, b3;
  1220.         if (sscanf(host, "%d.%d.%d.%d", &b0, &b1, &b2, &b3) == 4) {
  1221.         hp = (struct hostent *) calloc(1, sizeof(struct hostent));
  1222.         hp->h_addrtype = AF_INET;
  1223.         hp->h_length = 4;
  1224.         hp->h_addr_list = (char **) calloc(2, sizeof(char *));
  1225.         hp->h_addr_list[0] = (char *) malloc(4);
  1226.         hp->h_addr_list[0][0] = b0;
  1227.         hp->h_addr_list[0][1] = b1;
  1228.         hp->h_addr_list[0][2] = b2;
  1229.         hp->h_addr_list[0][3] = b3;
  1230.         } else {
  1231.         fprintf(stderr, "%s: could not gethostbyname %s\n",
  1232.             programName, host);
  1233.         return(-1);
  1234.         }
  1235.     }
  1236.     sa.sin_family = hp->h_addrtype;
  1237.     uport = (unsigned short) port;
  1238.     sa.sin_port = htons(uport);
  1239.     
  1240. #ifdef SVR4
  1241.         memcpy((char *) &sa.sin_addr, hp->h_addr, hp->h_length);
  1242. #else                /*!SVR4*/
  1243.         bcopy(hp->h_addr, (char *) &sa.sin_addr, hp->h_length);
  1244. #endif
  1245.  
  1246.     if ((s = socket(AF_INET, SOCK_STREAM, 6)) < 0) {
  1247.         fprintf(stderr, "%s: could not get socket\n", programName);
  1248.         return(-1);
  1249.     }
  1250.     if (connect(s, (struct sockaddr *) &sa, 
  1251.                 sizeof(struct sockaddr_in)) < 0) {
  1252.         fprintf(stderr, "%s: could not bind socket\n", programName);
  1253.         return(-1);
  1254.     }
  1255.     ics_input = ics_output = s;
  1256.     }
  1257.     return(0);
  1258. }
  1259.  
  1260. void read_from_player(client_data, file_num, id)
  1261.      caddr_t client_data;
  1262.      int *file_num;
  1263.      XtInputId *id;
  1264. {
  1265. #define BUF_SIZE 1024
  1266.     int s = *file_num;
  1267.     static char buf[BUF_SIZE];
  1268.     int buf_len, tmp_len;
  1269.     int out_len = 0;
  1270.     
  1271.     buf_len = read(s, buf, BUF_SIZE);
  1272.     
  1273.     if (buf_len > 0) {
  1274.     while (out_len < buf_len) {
  1275.         tmp_len = write(ics_output, &buf[out_len], buf_len - out_len);
  1276.         if (tmp_len == -1) {
  1277.         fprintf(stderr, "%s: error writing to ICS: ", programName);
  1278.         perror("");
  1279.         exit(1);
  1280.         }
  1281.         out_len += tmp_len;
  1282.     }
  1283.     } else {
  1284.     fprintf(stderr, "%s: got end of file from keyboard\n", programName);
  1285.     if (telnetPID != 0) {
  1286.         if (kill(telnetPID, SIGTERM) == 0)
  1287.           wait((union wait *) 0);
  1288.     }
  1289.     exit(0);
  1290.     }
  1291. }
  1292.  
  1293. void SendToICS(s)
  1294.      char *s;
  1295. {
  1296.     int i, j, tmp;
  1297.     
  1298.     i = strlen(s);
  1299.     j = 0;
  1300.     
  1301.     if (appData.debugMode)
  1302.       fprintf(stderr, "Sending to ICS: %s", s);
  1303.  
  1304.     while (j < i) {
  1305.     tmp = write(ics_output, &s[j], i - j);
  1306.     if (tmp == -1) {
  1307.         fprintf(stderr, "%s: error writing to ICS: ", programName);
  1308.         perror("");
  1309.         exit(1);
  1310.     }
  1311.     j += tmp;
  1312.     }
  1313. }
  1314.  
  1315.  
  1316. static int leftover_start = 0, leftover_len = 0;
  1317. static char star_match[8][256];
  1318.  
  1319. /* Test whether pattern is present at &buf[*index]; if so, return True,
  1320.    advance *index beyond it, and set leftover_start to the new value of
  1321.    *index; else return False.  If pattern contains the character '*', it
  1322.    matches any sequence of characters not containing '\r', '\n', or the
  1323.    character following the '*' (if any), and the matched sequence(s) are
  1324.    copied into star_match.  The pattern must not contain '\r' or '\n'.
  1325. */
  1326. Boolean looking_at(buf, index, pattern)
  1327.      char *buf;
  1328.      int *index;
  1329.      char *pattern;
  1330. {
  1331.     char *bufp = &buf[*index], *patternp = pattern;
  1332.     int star_count = 0;
  1333.     char *matchp = star_match[0];
  1334.     
  1335.     for (;;) {
  1336.     if (*patternp == NULLCHAR) {
  1337.         *index = leftover_start = bufp - buf;
  1338.         *matchp = NULLCHAR;
  1339.         return True;
  1340.     }
  1341.     if (*bufp == NULLCHAR) return False;
  1342.     if (*patternp == '*') {
  1343.         if (*bufp == *(patternp + 1)) {
  1344.         *matchp = NULLCHAR;
  1345.         matchp = star_match[++star_count];
  1346.         patternp += 2;
  1347.         bufp++;
  1348.         continue;
  1349.         } else if (*bufp == '\n' || *bufp == '\r') {
  1350.         patternp++;
  1351.         if (*patternp == NULLCHAR)
  1352.           continue;
  1353.         else
  1354.           return False;
  1355.         } else {
  1356.         *matchp++ = *bufp++;
  1357.         continue;
  1358.         }
  1359.     }
  1360.     if (*patternp != *bufp) return False;
  1361.     patternp++;
  1362.     bufp++;
  1363.     }
  1364. }
  1365.  
  1366.  
  1367. void read_from_ics(client_data, file_num, id)
  1368.      caddr_t client_data;
  1369.      int *file_num;
  1370.      XtInputId *id;
  1371. {
  1372. #define BUF_SIZE 1024
  1373. #define BOARD 1
  1374. #define MOVES 2
  1375.     
  1376.     static int started = 0;
  1377.     static char parse[20000];
  1378.     static int  parse_pos;
  1379.     static char buf[BUF_SIZE + 1];
  1380.     
  1381.     char str[500];
  1382.     int i, oldi;
  1383.     int buf_len;
  1384.     int next_out;
  1385.     
  1386.     /* If last read ended with a partial line that we couldn't parse,
  1387.        prepend it to the new read and try again. */
  1388.     if (leftover_len > 0) {
  1389.     for (i=0; i<leftover_len; i++)
  1390.       buf[i] = buf[leftover_start + i];
  1391.     }
  1392.     buf_len = read(ics_input, &buf[leftover_len], BUF_SIZE - leftover_len);
  1393.     next_out = leftover_len;
  1394.     
  1395.     if (buf_len > 0) {
  1396.     buf_len += leftover_len;
  1397.     leftover_start = 0;
  1398.     buf[buf_len] = NULLCHAR;
  1399.     
  1400.     i = 0;
  1401.     while (i < buf_len) {
  1402.         
  1403.         /* Skip over what people say */
  1404.         if (looking_at(buf, &i, "shouts: *") ||
  1405.         looking_at(buf, &i, "tells you: *") ||
  1406.         looking_at(buf, &i, "says: *") ||
  1407.         looking_at(buf, &i, "whispers: *") ||
  1408.         looking_at(buf, &i, "kibitzes: *")) {
  1409.         continue;
  1410.         }
  1411.  
  1412.         if (looking_at(buf, &i,
  1413.                "a   b   c   d   e   f   g   h") || 
  1414.         looking_at(buf, &i,
  1415.                "h   g   f   e   d   c   b   a")) {
  1416.         /* End of board style 1 */
  1417.         SendToICS("style 8\n");
  1418.                 SendToICS("refresh\n");
  1419.         continue;
  1420.         }
  1421.         
  1422.         oldi = i;
  1423.         if (looking_at(buf, &i, "#@#")) {
  1424.         started = BOARD;
  1425.         parse_pos = 0;
  1426.         fwrite(&buf[next_out], oldi - next_out, 1, stdout);
  1427.         continue;
  1428.         }
  1429.         
  1430.         if (started == BOARD && looking_at(buf, &i, "@#@")) {
  1431.         /* Board read is done */
  1432.         started = 0;
  1433.         next_out = i;
  1434.         parse[parse_pos] = NULLCHAR;
  1435.         
  1436.         /* Parse and display the board */
  1437.         ParseBoard8(parse);
  1438.         
  1439.         ics_user_moved = 0;
  1440.         continue;
  1441.         }
  1442.         
  1443.         oldi = i;
  1444.         if ((ics_getting_history || ics_mode == IcsIdle) &&
  1445.         looking_at(buf, &i, "Move ")) {
  1446.         /* Beginning of move list */
  1447.         started = MOVES;
  1448.         parse_pos = 0;
  1449.         fwrite(&buf[next_out], oldi - next_out, 1, stdout);
  1450.         continue;
  1451.         }                
  1452.         
  1453.         if(looking_at(buf, &i, "% ")) {
  1454.         switch (started) {
  1455.           case 0:
  1456.             continue;
  1457.           case BOARD:
  1458.             /* Something went wrong; found a prompt while
  1459.                accumulating a board */
  1460.             started = 0;
  1461.             fprintf(stderr, "%s: error gathering board\n",
  1462.                 programName);
  1463.             continue;
  1464.           case MOVES:
  1465.             started = 0;
  1466.             parse[parse_pos] = NULLCHAR;
  1467.             /* If moves came from oldmoves or moves command
  1468.                while in IcsIdle mode, load them in.  If the
  1469.                game was wild, we are already in "observing -1"
  1470.                mode because we've seen the initial board;
  1471.                otherwise we enter it here.
  1472.             */
  1473.             if (ics_mode == IcsIdle) {
  1474.             Reset(False);
  1475.             ics_mode = IcsObserving;
  1476.             ics_gamenum = -1;
  1477.             ics_getting_history = True;
  1478.             }
  1479.             if (ics_mode == IcsObserving && ics_gamenum == -1) {
  1480.             ParseGameHistory(parse);
  1481.             currentMove = forwardMostMove;
  1482.             DrawPosition(boardWidget, NULL, NULL, NULL);
  1483.             DisplayClocks(ReDisplayTimers);
  1484.             sprintf(str, "%s vs. %s", ics_white, ics_black);
  1485.             DisplayTitle(str);
  1486.             ics_mode = IcsIdle;
  1487.             } else {
  1488.             ParseGameHistory(parse);
  1489.             }
  1490.             DisplayMove(currentMove - 1);
  1491.             SendToICS("\n");  /*kludge: force a prompt*/
  1492.             next_out = i;
  1493.             ics_getting_history = False;
  1494.             continue;
  1495.         }
  1496.         }
  1497.         
  1498.         if (started && i >= leftover_len) {
  1499.         /* Accumulate characters in board
  1500.            or move list*/
  1501.         if (buf[i] != '\r')
  1502.           parse[parse_pos++] = buf[i];
  1503.         }
  1504.         
  1505.         /* Start of game messages.  Mostly we detect start of game
  1506.            when the first board image arrives, but we need to prime
  1507.            the pump for games we're just observing. */
  1508.         if (looking_at(buf, &i, "Adding game * to observation list")) {
  1509.         sprintf(str, "refresh %d\n", atoi(star_match[0]));
  1510.         SendToICS(str);
  1511.         continue;
  1512.         }
  1513.         
  1514.         /* Error messages */
  1515.         if (ics_user_moved) {
  1516.         if (looking_at(buf, &i, "No such command") ||
  1517.             looking_at(buf, &i, "Illegal move") ||
  1518.             looking_at(buf, &i, "Not a legal move") ||
  1519.             looking_at(buf, &i, "Your king is in check") ||
  1520.             looking_at(buf, &i, "It isn't your turn")) {
  1521.             /**** Illegal move ****/
  1522.             ics_user_moved = 0;
  1523.             if (forwardMostMove > backwardMostMove) {
  1524.             currentMove = --forwardMostMove;
  1525.             DisplayMessage("Illegal move");
  1526.             DrawPosition(boardWidget, NULL, NULL, NULL);
  1527.             DisplayClocks(SwitchTimers);
  1528.             }
  1529.             continue;
  1530.         }
  1531.         }
  1532.  
  1533.         if (looking_at(buf, &i, "You and your opponent still have time")) {
  1534.         /* We must have called his flag a little too soon */
  1535.         whiteFlag = blackFlag = False;
  1536.         continue;
  1537.         }
  1538.  
  1539.         /* End-of-game messages */
  1540.         if (looking_at(buf, &i, "{Game * (* vs. *)* * *}")) {
  1541.         /* New style generic game start/end messages */
  1542.         /* star_match[0] is the game number */
  1543.         /*           [1] is the white player's name */
  1544.         /*           [2] is the black player's name */
  1545.         /*           [3] is either ":" or empty (don't care) */
  1546.         /*           [4] is usually the loser's name or a noise word */
  1547.         /*           [5] contains the reason for the game end */
  1548.         int gamenum = atoi(star_match[0]);
  1549.         char *white = star_match[1];
  1550.         char *loser = star_match[4];
  1551.         char *why = star_match[5];
  1552.         
  1553.         if (ics_gamenum != gamenum) continue;
  1554.  
  1555.         if (StrStr(why, "checkmate")) {
  1556.             if (strcmp(loser, white) == 0)
  1557.               GameEnds("Black mates");
  1558.             else
  1559.               GameEnds("White mates");
  1560.         } else if (StrStr(why, "resign")) {
  1561.             if (strcmp(loser, white) == 0)
  1562.               GameEnds("White resigns");
  1563.             else
  1564.               GameEnds("Black resigns");
  1565.         } else if (StrStr(why, "forfeits on time")) {
  1566.             if (strcmp(loser, white) == 0)
  1567.               GameEnds("Black wins on time");
  1568.             else
  1569.               GameEnds("White wins on time");
  1570.         } else if (StrStr(why, "stalemate")) {
  1571.             GameEnds("Stalemate");
  1572.         } else if (StrStr(why, "drawn by mutual agreement")) {
  1573.             GameEnds("Draw agreed");
  1574.         } else if (StrStr(why, "repetition")) {
  1575.             GameEnds("Draw by repetition");
  1576.         } else if (StrStr(why, "50")) {
  1577.             GameEnds("Draw (50 move rule)");
  1578.         } else if (StrStr(why, "neither player has mating")) {
  1579.             GameEnds("Draw (insufficient material)");
  1580.         } else if (StrStr(why, "no material")) {
  1581.             GameEnds("Draw (insufficient material to win on time)");
  1582.         } else if (StrStr(why, "time")) {
  1583.             GameEnds("Draw (both players ran out of time)");
  1584.         } else if (StrStr(why, "disconnected and forfeits")) {
  1585.             /* in this case the word "abuser" preceded the loser */
  1586.             loser = why;
  1587.             why = strchr(loser, ' ');
  1588.             *why++ = NULLCHAR;
  1589.             if (strcmp(loser, white) == 0)
  1590.               GameEnds("Black wins (forfeit)");
  1591.             else
  1592.               GameEnds("White wins (forfeit)");
  1593.         } else if (StrStr(why, "assert")) {
  1594.             /* "loser" is actually the winner in this case */
  1595.             if (strcmp(loser, white) == 0)
  1596.               GameEnds("White asserts a win");
  1597.             else
  1598.               GameEnds("Black asserts a win");
  1599.         } else if (StrStr(why, "aborted")) {
  1600.             DisplayClocks(StopTimers);
  1601.             DisplayMessage("Game aborted");
  1602.             ics_mode = IcsIdle;
  1603.             ics_gamenum = -1;
  1604.             ics_user_moved = False;
  1605.         } else if (StrStr(why, "removed")) {
  1606.             DisplayClocks(StopTimers);
  1607.             DisplayMessage("Game aborted");
  1608.             ics_mode = IcsIdle;
  1609.             ics_gamenum = -1;
  1610.             ics_user_moved = False;
  1611.         } else if (StrStr(why, "adjourn")) {
  1612.             DisplayClocks(StopTimers);
  1613.             DisplayMessage("Game adjourned");
  1614.             ics_mode = IcsIdle;
  1615.             ics_gamenum = -1;
  1616.             ics_user_moved = False;
  1617.         }   
  1618.         continue;
  1619.         }
  1620.  
  1621.         if (looking_at(buf, &i, "Removing game * from observation list")) {
  1622.         if (ics_mode == IcsObserving &&
  1623.             atoi(star_match[0]) == ics_gamenum)
  1624.           {
  1625.               DisplayClocks(StopTimers);
  1626.               ics_mode = IcsIdle;
  1627.               ics_gamenum = -1;
  1628.               ics_user_moved = False;
  1629.           }
  1630.         continue;
  1631.         }
  1632.  
  1633.         /* Advance leftover_start past any newlines we find,
  1634.            so only partial lines can get reparsed */
  1635.         if (looking_at(buf, &i, "\n")) continue;
  1636.         if (looking_at(buf, &i, "\r")) continue;
  1637.         
  1638.         i++;    /* skip unparsed character and loop back */
  1639.     }
  1640.     
  1641.     if (started == 0)
  1642.       fwrite(&buf[next_out], i - next_out, 1, stdout);
  1643.     
  1644.     leftover_len = buf_len - leftover_start;
  1645.     /* if buffer ends with something we couldn't parse,
  1646.        reparse it after appending the next read */
  1647.     
  1648.     } else if (buf_len == 0) {
  1649.     fprintf(stderr, "%s: connection closed by ICS\n", programName);
  1650.     if (telnetPID != 0) {
  1651.         if (kill(telnetPID, SIGTERM) == 0)
  1652.           wait((union wait *) 0);
  1653.     }
  1654.     exit(0);
  1655.     } else {
  1656.     fprintf(stderr, "%s: error reading from ICS: ", programName);
  1657.     perror("");
  1658.     exit(1);
  1659.     }
  1660. }
  1661.  
  1662. /*
  1663.   ICS board style 8 looks like this:
  1664.   
  1665.   #@#000observer        :aaa             :RNBQKBNRPPPPPPPP                                pppppppprnbqkbnr001W39390360003600@#@
  1666.   
  1667.   Information offsets, descriptions and lengths:
  1668.   +3   Game # (3)
  1669.   +6   White's name (16 + ':' = 17)
  1670.   +23  Black's name (16 + ':' = 17)
  1671.   +40  Board  (64)
  1672.   +104 Move # (3)
  1673.   +107 Whose move (1)
  1674.   +108 White Strength (2)
  1675.   +110 Black Strength (2)
  1676.   +112 White Time (5)
  1677.   +117 Black Time (5)
  1678.   +122 Move string (variable
  1679.   A "*" instead of a ":" after the name implies that the person using xboard
  1680.     is playing the game.
  1681.   The move string is either empty or consists of a move followed by
  1682.     elapsed time in parentheses.
  1683.   The pattern defined below doesn't include the #@# and @#@ brackets,
  1684.     and it assumes the board string is null-terminated.  ParseBoard8's
  1685.     caller takes care of this.
  1686.   */
  1687.  
  1688. #define PATTERN "%3d%16s %1c%16s %1c%64c%3d%1c%2d%2d%5d%5d%s %s"
  1689.  
  1690. void ParseBoard8(string)
  1691.      char *string;
  1692. { 
  1693.     IcsMode new_ics_mode;
  1694.     int gamenum;
  1695.     int j, k, n, move_num, white_stren, black_stren, white_time, black_time;
  1696.     char playing_white, playing_black, to_play, board_chars[64];
  1697.     char move_str[500], str[500], elapsed_time[500];
  1698.     char black[32], white[32];
  1699.     Board board;
  1700.     
  1701.     if (appData.debugMode)
  1702.       fprintf(stderr, "Parsing board: %s\n", string);
  1703.  
  1704.     move_str[0] = NULLCHAR;
  1705.     elapsed_time[0] = NULLCHAR;
  1706.     
  1707.     n = sscanf(string, PATTERN, &gamenum, white, &playing_white,
  1708.            black, &playing_black, board_chars, &move_num, &to_play,
  1709.            &white_stren, &black_stren, &white_time, &black_time,
  1710.            move_str, elapsed_time);
  1711.     if (n < 12) {
  1712.     fprintf(stderr, "%s: Failed to parse board string: '%s'\n",
  1713.         programName, string);
  1714.     return;
  1715.     }
  1716.  
  1717.     if (playing_white == '*')
  1718.       new_ics_mode = IcsPlayingWhite;
  1719.     else if (playing_black == '*')
  1720.       new_ics_mode = IcsPlayingBlack;
  1721.     else
  1722.       new_ics_mode = IcsObserving;
  1723.     
  1724.     /* Convert the move number to internal form */
  1725.     move_num = (move_num - 1) * 2;
  1726.     if (to_play == 'B') move_num++;
  1727.  
  1728.     /* Deal with initial board display for wild games */
  1729.     if (gamenum == -1) {
  1730.     if (ics_mode == IcsIdle) {
  1731.         /* Initial board for "moves" or "oldmoves" output
  1732.            that we are going to parse.  Go into IcsObserving
  1733.            state with ics_gamenum = -1.
  1734.         */
  1735.         Reset(False);
  1736.         ics_mode = IcsObserving;
  1737.         ics_gamenum = -1;
  1738.         ics_getting_history = True;
  1739.     } else {
  1740.         /* Ignore this board */
  1741.         return;
  1742.     }
  1743.     }
  1744.  
  1745.     /* Take action if this is the first board of a new game */
  1746.     if (gamenum != ics_gamenum) {
  1747.     if (ics_mode == IcsObserving) {
  1748.         /* Error: xboard can't handle two games at once */
  1749.         /* Stop observing the old game */
  1750.         fprintf(stderr, "%s: Aren't you currently observing game %d",
  1751.             programName, ics_gamenum);
  1752.         fprintf(stderr, "?  Attempting to stop observing it.\n");
  1753.         sprintf(str, "observe %d\n", ics_gamenum);
  1754.         SendToICS(str);
  1755.         /* continue as in normal case */
  1756.     } else if (ics_mode != IcsIdle) {
  1757.         /* Error: xboard can't handle two games at once */
  1758.         if (new_ics_mode == IcsObserving) {
  1759.         /* Stop observing the new game */
  1760.         fprintf(stderr, "%s: Aren't you playing a game now?  ",
  1761.             programName);
  1762.         fprintf(stderr, "Attempting to stop observing game %d.\n",
  1763.             gamenum);
  1764.         SendToICS("observe\n");
  1765.         /* ignore this board */
  1766.         return;
  1767.         } else /* new_ics_mode == IcsPlaying(White|Black) */ {
  1768.         /* Playing two games???  ICS supposedly can't do this. */
  1769.         fprintf(stderr, "%s: BUG: playing two games (%d and %d)\n",
  1770.             programName, ics_gamenum, gamenum);
  1771.         /* continue as in normal case, hoping old game is gone */
  1772.         }
  1773.     }
  1774.     /* Normal case (ics_mode == IcsIdle), or error recovered */
  1775.     Reset(False);
  1776.     if (move_num > 0) {
  1777.         /* Need to get game history */
  1778.         ics_getting_history = True;
  1779.         sprintf(str, "moves %d\n", gamenum);
  1780.         SendToICS(str);
  1781.     }
  1782.     }
  1783.  
  1784.     /* Initially flip the board to have black on the bottom iff playing
  1785.        black, but let the user change it with the Flip View button. */
  1786.     if (ics_mode == IcsIdle)
  1787.       flipView = (new_ics_mode == IcsPlayingBlack);
  1788.  
  1789.     /* Update known move number limits */
  1790.     if (ics_mode == IcsIdle) {
  1791.     forwardMostMove = backwardMostMove = currentMove = move_num;
  1792.     } else if (move_num > forwardMostMove) {
  1793.     forwardMostMove = move_num;
  1794.     if (gameMode != PauseGame) 
  1795.       currentMove = move_num;
  1796.     }
  1797.  
  1798.     /* Done with values from previous mode; copy in new ones */
  1799.     ics_mode = new_ics_mode;
  1800.     ics_gamenum = gamenum;
  1801.     strcpy(ics_white, white);
  1802.     strcpy(ics_black, black);
  1803.  
  1804.     /* Parse the board */
  1805.     for (k = 0; k < 8; k++)
  1806.       for (j = 0; j < 8; j++)
  1807.     board[k][j] = CharToPiece(board_chars[k*8 + j]);
  1808.     CopyBoard(boards[move_num], board);
  1809.     if (move_num == 0) {
  1810.     startedFromSetupPosition =
  1811.       !CompareBoards(board, initialPosition);
  1812.     }
  1813.  
  1814.     /* Put the move on the move list, first converting
  1815.        to canonical algebraic form. */
  1816.     if (move_num > 0) {
  1817.     ChessMove move_type;
  1818.     int from_x, from_y, to_x, to_y;
  1819.     char promo_char;
  1820.  
  1821.     if (move_num - 1 < backwardMostMove) {
  1822.         /* We don't know what the board looked like before
  1823.            this move.  Punt. */
  1824.         strcpy(parseList[move_num - 1], move_str);
  1825.     } else {
  1826.         ParseMachineMove(move_str, move_num - 1, &move_type,
  1827.                  &from_x, &from_y, &to_x, &to_y, &promo_char);
  1828.  
  1829.         /* Work around ICS bug: pawn promotion is not indicated,
  1830.            even if underpromoted.  Unfortunately there is no
  1831.            workaround for the same bug when it bites us in
  1832.            ParseGameHistory().
  1833.         */
  1834.         if (move_str[0] == 'P' && (to_y == 0 || to_y == 7))
  1835.           promo_char = ToLower(PieceToChar(board[to_y][to_x]));
  1836.  
  1837.         (void) CoordsToAlgebraic(from_x, from_y, to_x, to_y, promo_char,
  1838.                      move_num - 1, parseList[move_num - 1]);
  1839.         strcat(parseList[move_num - 1], " ");
  1840.         strcat(parseList[move_num - 1], elapsed_time);
  1841.     }
  1842.     }
  1843.     
  1844.     if (move_num < forwardMostMove || ics_gamenum == -1) return;
  1845.  
  1846.     /* Update and display the clocks */
  1847.     timeRemaining[0][move_num] = whiteTimeRemaining = white_time * 1000;
  1848.     timeRemaining[1][move_num] = blackTimeRemaining = black_time * 1000;
  1849.     DisplayClocks(StartTimers);
  1850.  
  1851.     /* Display opponents and material strengths */
  1852.     sprintf(str, "%s (%d) vs. %s (%d)",
  1853.         ics_white, white_stren, ics_black, black_stren);
  1854.     DisplayTitle(str);
  1855.     
  1856.     /* Display the board */
  1857.     if (gameMode != PauseGame) {
  1858.     DrawPosition(boardWidget, NULL, NULL, NULL);
  1859.     DisplayMove(move_num - 1);
  1860.     if (appData.ringBellAfterMoves && !ics_user_moved)
  1861.       putc(BELLCHAR, stderr);
  1862.     }
  1863. }
  1864.  
  1865.  
  1866. #define abs(n) ((n)<0 ? -(n) : (n))
  1867.  
  1868. /*
  1869.  * Find a font that matches "pattern" that is as close as
  1870.  * possible to the targetPxlSize.  Prefer fonts that are k
  1871.  * pixels smaller to fonts that are k pixels larger.  The
  1872.  * pattern must be in the X Consortium standard format, 
  1873.  * e.g. "-*-helvetica-bold-r-normal--*-*-*-*-*-*-*-*".
  1874.  * The return value should be freed with XtFree when no
  1875.  * longer needed.
  1876.  */
  1877. char *FindFont(pattern, targetPxlSize)
  1878.      char *pattern;
  1879.      int targetPxlSize;
  1880. {
  1881.     char **fonts, *p, *best;
  1882.     int i, j, nfonts, minerr, err, pxlSize;
  1883.  
  1884.     fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);
  1885.     if (nfonts < 1) {
  1886.     fprintf(stderr, "%s: No fonts match pattern %s\n",
  1887.         programName, pattern);
  1888.     exit(1);
  1889.     }
  1890.     best = "";
  1891.     minerr = 999999;
  1892.     for (i=0; i<nfonts; i++) {
  1893.     j = 0;
  1894.     p = fonts[i];
  1895.     if (*p != '-') continue;
  1896.     while (j < 7) {
  1897.         if (*p == NULLCHAR) break;
  1898.         if (*p++ == '-') j++;
  1899.     }
  1900.     if (j < 7) continue;
  1901.     pxlSize = atoi(p);
  1902.     if (pxlSize == targetPxlSize) {
  1903.         best = fonts[i];
  1904.         break;
  1905.     }
  1906.     err = pxlSize - targetPxlSize;
  1907.     if (abs(err) < abs(minerr) ||
  1908.         (minerr > 0 && err < 0 && -err == minerr)) {
  1909.         best = fonts[i];
  1910.         minerr = err;
  1911.     }
  1912.     }
  1913.     p = (char *) XtMalloc(strlen(best) + 1);
  1914.     strcpy(p, best);
  1915.     XFreeFontNames(fonts);
  1916.     return p;
  1917. }
  1918.  
  1919. void CreateGCs()
  1920. {
  1921.     XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground
  1922.       | GCBackground | GCFunction | GCPlaneMask;
  1923.     XGCValues gc_values;
  1924.     
  1925.     gc_values.plane_mask = AllPlanes;
  1926.     gc_values.line_width = LINE_GAP;
  1927.     gc_values.line_style = LineSolid;
  1928.     gc_values.function = GXcopy;
  1929.     
  1930.     gc_values.foreground = XBlackPixel(xDisplay, xScreen);
  1931.     gc_values.background = XBlackPixel(xDisplay, xScreen);
  1932.     lineGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1933.     
  1934.     gc_values.background = XWhitePixel(xDisplay, xScreen);
  1935.     coordGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1936.     XSetFont(xDisplay, coordGC, coordFontID);
  1937.     
  1938.     if (appData.monoMode) {
  1939.     gc_values.foreground = XWhitePixel(xDisplay, xScreen);
  1940.     gc_values.background = XBlackPixel(xDisplay, xScreen);
  1941.     lightSquareGC = wbPieceGC
  1942.       = XtGetGC(shellWidget, value_mask, &gc_values);
  1943.     
  1944.     gc_values.foreground = XBlackPixel(xDisplay, xScreen);
  1945.     gc_values.background = XWhitePixel(xDisplay, xScreen);
  1946.     darkSquareGC = bwPieceGC
  1947.       = XtGetGC(shellWidget, value_mask, &gc_values);
  1948.     } else {
  1949.     gc_values.foreground = appData.lightSquareColor;
  1950.     gc_values.background = appData.darkSquareColor;
  1951.     lightSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1952.     
  1953.     gc_values.foreground = appData.darkSquareColor;
  1954.     gc_values.background = appData.lightSquareColor;
  1955.     darkSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1956.     
  1957.     gc_values.foreground = appData.whitePieceColor;
  1958.     gc_values.background = appData.darkSquareColor;
  1959.     wdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1960.     
  1961.     gc_values.foreground = appData.whitePieceColor;
  1962.     gc_values.background = appData.lightSquareColor;
  1963.     wlPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1964.     
  1965.     gc_values.foreground = appData.blackPieceColor;
  1966.     gc_values.background = appData.darkSquareColor;
  1967.     bdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1968.     
  1969.     gc_values.foreground = appData.blackPieceColor;
  1970.     gc_values.background = appData.lightSquareColor;
  1971.     blPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1972.     }
  1973. }
  1974.  
  1975. void CreatePieces()
  1976. {
  1977.     XSynchronize(xDisplay, True); /* Work-around for xlib/xt
  1978.                      buffering bug */
  1979.     
  1980.     ReadBitmap(appData.solidPawnBitmap, &solidPawnBitmap,
  1981.            s_p_bits, sm_s_p_bits, xs_s_p_bits);
  1982.     ReadBitmap(appData.solidRookBitmap, &solidRookBitmap,
  1983.            s_r_bits, sm_s_r_bits, xs_s_r_bits);
  1984.     ReadBitmap(appData.solidKnightBitmap, &solidKnightBitmap,
  1985.            s_n_bits, sm_s_n_bits, xs_s_n_bits);
  1986.     ReadBitmap(appData.solidBishopBitmap, &solidBishopBitmap,
  1987.            s_b_bits, sm_s_b_bits, xs_s_b_bits);
  1988.     ReadBitmap(appData.solidQueenBitmap, &solidQueenBitmap,
  1989.            s_q_bits, sm_s_q_bits, xs_s_q_bits);
  1990.     ReadBitmap(appData.solidKingBitmap, &solidKingBitmap,
  1991.            s_k_bits, sm_s_k_bits, xs_s_k_bits);
  1992.     
  1993.     if (appData.monoMode) {
  1994.     ReadBitmap(appData.outlinePawnBitmap, &outlinePawnBitmap,
  1995.            ol_p_bits, sm_ol_p_bits, xs_ol_p_bits);
  1996.     ReadBitmap(appData.outlineRookBitmap, &outlineRookBitmap,
  1997.            ol_r_bits, sm_ol_r_bits, xs_ol_r_bits);
  1998.     ReadBitmap(appData.outlineKnightBitmap, &outlineKnightBitmap,
  1999.            ol_n_bits, sm_ol_n_bits, xs_ol_n_bits);
  2000.     ReadBitmap(appData.outlineBishopBitmap, &outlineBishopBitmap,
  2001.            ol_b_bits, sm_ol_b_bits, xs_ol_b_bits);
  2002.     ReadBitmap(appData.outlineQueenBitmap, &outlineQueenBitmap,
  2003.            ol_q_bits, sm_ol_q_bits, xs_ol_q_bits);
  2004.     ReadBitmap(appData.outlineKingBitmap, &outlineKingBitmap,
  2005.            ol_k_bits, sm_ol_k_bits, xs_ol_k_bits);
  2006.     }
  2007.     
  2008.     XSynchronize(xDisplay, False); /* Work-around for xlib/xt
  2009.                       buffering bug */
  2010. }
  2011.  
  2012. void ReadBitmap(name, pm, large_bits, medium_bits, small_bits)
  2013.      String name;
  2014.      Pixmap *pm;
  2015.      char large_bits[], medium_bits[], small_bits[];
  2016. {
  2017.     int x_hot, y_hot;
  2018.     u_int w, h;
  2019.     
  2020.     if (*name == NULLCHAR ||
  2021.     XReadBitmapFile(xDisplay, xBoardWindow, name,
  2022.             &w, &h, pm, &x_hot, &y_hot) != BitmapSuccess ||
  2023.     w != squareSize || h != squareSize) {
  2024.     switch (boardSize) {
  2025.       case Large:
  2026.         *pm = XCreateBitmapFromData(xDisplay, xBoardWindow,
  2027.                     large_bits, squareSize, squareSize);
  2028.         break;
  2029.       case Medium:
  2030.         *pm = XCreateBitmapFromData(xDisplay, xBoardWindow,
  2031.                     medium_bits, squareSize, squareSize);
  2032.         break;
  2033.       case Small:
  2034.         *pm = XCreateBitmapFromData(xDisplay, xBoardWindow,
  2035.                     small_bits, squareSize, squareSize);
  2036.         break;
  2037.     }
  2038.     }
  2039. }
  2040.  
  2041. void CreateGrid()
  2042. {
  2043.     int i;
  2044.     
  2045.     for (i = 0; i < BOARD_SIZE + 1; i++) {
  2046.     gridSegments[i].x1 = gridSegments[i + BOARD_SIZE + 1].y1 = 0;
  2047.     gridSegments[i].y1 = gridSegments[i].y2
  2048.       = LINE_GAP / 2 + (i * (squareSize + LINE_GAP));
  2049.     gridSegments[i].x2 = LINE_GAP + BOARD_SIZE *
  2050.       (squareSize + LINE_GAP);
  2051.     gridSegments[i + BOARD_SIZE + 1].x1 =
  2052.       gridSegments[i + BOARD_SIZE + 1].x2 = LINE_GAP / 2
  2053.         + (i * (squareSize + LINE_GAP));
  2054.     gridSegments[i + BOARD_SIZE + 1].y2 =
  2055.       BOARD_SIZE * (squareSize + LINE_GAP);
  2056.     }
  2057. }
  2058.  
  2059. void CreatePieceMenus()
  2060. {
  2061.     int i;
  2062.     Widget entry;
  2063.     Arg args[1];
  2064.     ChessSquare selection;
  2065.     
  2066.     XtSetArg(args[0], XtNlabel, "White");
  2067.     whitePieceMenu = XtCreatePopupShell("menuW", simpleMenuWidgetClass,
  2068.                     boardWidget, args, 1);
  2069.     for (i = 0; i < PIECE_MENU_SIZE; i++) {
  2070.     String item = pieceMenuStrings[i];
  2071.     
  2072.     if (strcmp(item, "----") == 0) {
  2073.         entry = XtCreateManagedWidget(item, smeLineObjectClass,
  2074.                       whitePieceMenu, NULL, 0);
  2075.     } else {
  2076.         entry = XtCreateManagedWidget(item, smeBSBObjectClass,
  2077.                       whitePieceMenu, NULL, 0);
  2078.         selection = pieceMenuTranslation[0][i];
  2079.         XtAddCallback(entry, XtNcallback,
  2080.               (XtCallbackProc) PieceMenuSelect,
  2081.               (caddr_t) selection);
  2082.         if (selection == WhitePawn) {
  2083.         XtSetArg(args[0], XtNpopupOnEntry, entry);
  2084.         XtSetValues(whitePieceMenu, args, 1);
  2085.         }
  2086.     }
  2087.     }
  2088.     
  2089.     XtSetArg(args[0], XtNlabel, "Black");
  2090.     blackPieceMenu = XtCreatePopupShell("menuB", simpleMenuWidgetClass,
  2091.                     boardWidget, args, 1);
  2092.     for (i = 0; i < PIECE_MENU_SIZE; i++) {
  2093.     String item = pieceMenuStrings[i];
  2094.     
  2095.     if (strcmp(item, "----") == 0) {
  2096.         entry = XtCreateManagedWidget(item, smeLineObjectClass,
  2097.                       blackPieceMenu, NULL, 0);
  2098.     } else {
  2099.         entry = XtCreateManagedWidget(item, smeBSBObjectClass,
  2100.                       blackPieceMenu, NULL, 0);
  2101.         selection = pieceMenuTranslation[1][i];
  2102.         XtAddCallback(entry, XtNcallback,
  2103.               (XtCallbackProc) PieceMenuSelect,
  2104.               (caddr_t) selection);
  2105.         if (selection == BlackPawn) {
  2106.         XtSetArg(args[0], XtNpopupOnEntry, entry);
  2107.         XtSetValues(blackPieceMenu, args, 1);
  2108.         }
  2109.     }
  2110.     }
  2111.     
  2112.     XtRegisterGrabAction(PieceMenuPopup, True,
  2113.              (unsigned)(ButtonPressMask|ButtonReleaseMask),
  2114.              GrabModeAsync, GrabModeAsync);
  2115. }    
  2116.  
  2117. void PieceMenuPopup(w, event, params, num_params)
  2118.      Widget w;
  2119.      XEvent *event;
  2120.      String *params;
  2121.      Cardinal *num_params;
  2122. {
  2123.     if (event->type != ButtonPress) return;
  2124.     if (gameMode != EditPosition) return;
  2125.     
  2126.     if (((pmFromX = EventToSquare(event->xbutton.x)) < 0) ||
  2127.     ((pmFromY = EventToSquare(event->xbutton.y)) < 0)) {
  2128.     pmFromX = pmFromY = -1;
  2129.     return;
  2130.     }
  2131.     if (flipView)
  2132.       pmFromX = BOARD_SIZE - 1 - pmFromX;
  2133.     else
  2134.       pmFromY = BOARD_SIZE - 1 - pmFromY;
  2135.     
  2136.     XtPopupSpringLoaded(XtNameToWidget(boardWidget, params[0]));
  2137. }
  2138.  
  2139. static void PieceMenuSelect(w, piece, junk)
  2140.      Widget w;
  2141.      ChessSquare piece;
  2142.      caddr_t junk;
  2143. {
  2144.     if (pmFromX < 0 || pmFromY < 0) return;
  2145.     switch (piece) {
  2146.       case ClearBoard:
  2147.     for (pmFromY = 0; pmFromY < BOARD_SIZE; pmFromY++)
  2148.       for (pmFromX = 0; pmFromX < BOARD_SIZE; pmFromX++)
  2149.           boards[0][pmFromY][pmFromX] = EmptySquare;
  2150.     DrawPosition(boardWidget, NULL, NULL, NULL);
  2151.     break;
  2152.     
  2153.       case WhitePlay:    /*not currently on menu*/
  2154.     SetWhiteToPlay(NULL, NULL, NULL, NULL);
  2155.     break;
  2156.     
  2157.       case BlackPlay:    /*not currently on menu*/
  2158.     SetBlackToPlay(NULL, NULL, NULL, NULL);
  2159.     break;
  2160.     
  2161.       default:
  2162.     boards[0][pmFromY][pmFromX] = piece;
  2163.     DrawPosition(boardWidget, NULL, NULL, NULL);
  2164.     break;
  2165.     }
  2166.     XSync(xDisplay, False);
  2167. }
  2168.  
  2169. static void SetWhiteToPlay(w, event, prms, nprms)
  2170.      Widget w;
  2171.      XEvent *event;
  2172.      String *prms;
  2173.      Cardinal *nprms;
  2174. {
  2175.     if (gameMode != EditPosition) return;
  2176.     blackPlaysFirst = False;
  2177.     DisplayClocks(ReDisplayTimers); /* works because currentMove is 0 */
  2178. }
  2179.  
  2180. static void SetBlackToPlay(w, event, prms, nprms)
  2181.      Widget w;
  2182.      XEvent *event;
  2183.      String *prms;
  2184.      Cardinal *nprms;
  2185. {
  2186.     if (gameMode != EditPosition) return;
  2187.     blackPlaysFirst = True;
  2188.     currentMove = 1;    /* kludge */
  2189.     DisplayClocks(ReDisplayTimers);
  2190.     currentMove = 0;
  2191. }
  2192.  
  2193. char PieceToChar(p)
  2194.      ChessSquare p;
  2195. {
  2196.     return pieceToChar[(int) p];
  2197. }
  2198.  
  2199. ChessSquare CharToPiece(c)
  2200.      int c;
  2201. {
  2202.     switch (c) {
  2203.       default:
  2204.       case '.':    return EmptySquare;
  2205.       case 'P':    return WhitePawn;
  2206.       case 'R':    return WhiteRook;
  2207.       case 'N':    return WhiteKnight;
  2208.       case 'B':    return WhiteBishop;
  2209.       case 'Q':    return WhiteQueen;
  2210.       case 'K':    return WhiteKing;
  2211.       case 'p':    return BlackPawn;
  2212.       case 'r':    return BlackRook;
  2213.       case 'n':    return BlackKnight;
  2214.       case 'b':    return BlackBishop;
  2215.       case 'q':    return BlackQueen;
  2216.       case 'k':    return BlackKing;
  2217.     }
  2218. }
  2219.  
  2220. ChessSquare PromoPiece(move_type)
  2221.      ChessMove move_type;
  2222. {
  2223.     switch (move_type) {
  2224.       default:
  2225.     return EmptySquare;
  2226.       case WhitePromotionQueen:
  2227.     return WhiteQueen;
  2228.       case BlackPromotionQueen:
  2229.     return BlackQueen;
  2230.       case WhitePromotionRook:
  2231.     return WhiteRook;
  2232.       case BlackPromotionRook:
  2233.     return BlackRook;
  2234.       case WhitePromotionBishop:
  2235.     return WhiteBishop;
  2236.       case BlackPromotionBishop:
  2237.     return BlackBishop;
  2238.       case WhitePromotionKnight:
  2239.     return WhiteKnight;
  2240.       case BlackPromotionKnight:
  2241.     return BlackKnight;
  2242.     }
  2243. }
  2244.  
  2245.  
  2246. /* Convert coordinates to normal algebraic notation.
  2247.    promoChar must be NULLCHAR or '.' if not a promotion.
  2248.    */
  2249. ChessMove CoordsToAlgebraic(fromX, fromY, toX, toY, promoChar,
  2250.                 currentBoardIndex, out)
  2251.      int fromX, fromY, toX, toY;
  2252.      int promoChar;
  2253.      int currentBoardIndex;
  2254.      char out[MOVE_LEN];
  2255. {
  2256.     ChessSquare piece;
  2257.     ChessMove ret;
  2258.     char *outp = out;
  2259.     int i;
  2260.     
  2261.     if (promoChar == '.') promoChar = NULLCHAR;
  2262.     piece = boards[currentBoardIndex][fromY][fromX];
  2263.     switch (piece) {
  2264.       case WhitePawn:
  2265.       case BlackPawn:
  2266.     /* Pawn move */
  2267.     *outp++ = fromX + 'a';
  2268.     if (fromX == toX) {
  2269.         /* Non-capture; use style "e5" or "e8Q" */
  2270.         *outp++ = toY + '1';
  2271.         *outp++ = ToUpper(promoChar);
  2272.         *outp = NULLCHAR;
  2273.     } else {
  2274.         /* Capture; use style "exd5" or "exd8Q" */
  2275.         *outp++ = 'x';
  2276.         *outp++ = toX + 'a';
  2277.         *outp++ = toY + '1';
  2278.         *outp++ = ToUpper(promoChar);
  2279.         *outp = NULLCHAR;
  2280.     }
  2281.     
  2282.     /* Test if okay by parsing; this notation should parse 
  2283.        unambiguously if the original move was legal.  More
  2284.        code would be needed if we wanted the style "ed" for
  2285.        captures, since that can be ambiguous.
  2286.        */
  2287.     ret = yylexstr(currentBoardIndex, out, (char **) NULL);
  2288.     break;
  2289.     
  2290.       case WhiteKing:
  2291.       case BlackKing:
  2292.     /* Test for castling or ICS wild castling */
  2293.     /* Use style "0-0" (zero-zero) */
  2294.     if (fromY == toY &&
  2295.         fromY == ((piece == WhiteKing) ? 0 : 7) &&
  2296.         ((fromX == 4 && (toX == 2 || toX == 6)) ||
  2297.          (fromX == 3 && (toX == 1 || toX == 5)))) {
  2298.         switch (toX) {
  2299.           case 1:
  2300.           case 6:
  2301.         strcpy(out, "0-0");
  2302.         break;
  2303.           case 2:
  2304.           case 5:
  2305.         strcpy(out, "0-0-0");
  2306.         break;
  2307.         }
  2308.         ret = yylexstr(currentBoardIndex, out, (char **) NULL);
  2309.         break;
  2310.     }
  2311.     /* else fall through */
  2312.     
  2313.       default:
  2314.     /* Piece move */
  2315.     /* First try style "Nf3" or "Nxf7" */
  2316.     *outp++ = ToUpper(PieceToChar(piece));
  2317.     
  2318.     /* Capture? */
  2319.     if(boards[currentBoardIndex][toY][toX] != EmptySquare)
  2320.       *outp++ = 'x';
  2321.     
  2322.     *outp++ = toX + 'a';
  2323.     *outp++ = toY + '1';
  2324.     *outp = NULLCHAR;
  2325.     
  2326.     /* Test if ambiguous */
  2327.     ret = yylexstr(currentBoardIndex, out, (char **) NULL);
  2328.     if (ret != AmbiguousMove) break;
  2329.     
  2330.     /* Try style "Ngf3" or "Nexf7" */
  2331.     for (i=4; i>=1; i--) out[i+1] = out[i];
  2332.     out[1] = fromX + 'a';
  2333.     
  2334.     /* Test if ambiguous */
  2335.     ret = yylexstr(currentBoardIndex, out, (char **) NULL);
  2336.     if (ret != AmbiguousMove) break;
  2337.     
  2338.     /* Try style "N1f3" */
  2339.     out[1] = fromY + '1';
  2340.     
  2341.     /* Test if ambiguous */
  2342.     ret = yylexstr(currentBoardIndex, out, (char **) NULL);
  2343.     if (ret != AmbiguousMove) break;
  2344.     
  2345.     /* Try style "Ng1f3" or "Ne5xf7" */
  2346.     /* Can be needed iff there are 3 or more pieces of the
  2347.        type being moved on the board, due to promotion */
  2348.     for (i=5; i>=2; i--) out[i+1] = out[i];
  2349.     out[1] = fromX + 'a';
  2350.     out[2] = fromY + '1';
  2351.     
  2352.     /* Test if okay */
  2353.     ret = yylexstr(currentBoardIndex, out, (char **) NULL);
  2354.     break; 
  2355.     
  2356.       case EmptySquare:
  2357.     /* Illegal move; use coordinate notation */
  2358.     *outp++ = fromX + 'a';
  2359.     *outp++ = fromY + '1';
  2360.     *outp++ = toX + 'a';
  2361.     *outp++ = toY + '1';
  2362.     *outp++ = ToUpper(promoChar);
  2363.     *outp = NULLCHAR;
  2364.     return BadMove;
  2365.     }
  2366.     
  2367.     switch (ret) {
  2368.       case NormalMove:
  2369.       case WhitePromotionKnight:
  2370.       case WhitePromotionBishop:
  2371.       case WhitePromotionRook:
  2372.       case WhitePromotionQueen:
  2373.       case BlackPromotionKnight:
  2374.       case BlackPromotionBishop:
  2375.       case BlackPromotionRook:
  2376.       case BlackPromotionQueen:
  2377.       case WhiteCapturesEnPassant:
  2378.       case BlackCapturesEnPassant:
  2379.       case WhiteKingSideCastle:
  2380.       case WhiteQueenSideCastle:
  2381.       case BlackKingSideCastle:
  2382.       case BlackQueenSideCastle:
  2383.       case WhiteKingSideCastleWild:
  2384.       case WhiteQueenSideCastleWild:
  2385.       case BlackKingSideCastleWild:
  2386.       case BlackQueenSideCastleWild:
  2387.     if (currentMoveString[0] != fromX + 'a' ||
  2388.         currentMoveString[1] != fromY + '1' ||
  2389.         currentMoveString[2] != toX + 'a' ||
  2390.         currentMoveString[3] != toY + '1' ||
  2391.         (promoChar != NULLCHAR &&
  2392.          currentMoveString[4] != ToLower(promoChar))) {
  2393.         /* Illegal move; use coordinate notation */
  2394.         outp = out;
  2395.         *outp++ = fromX + 'a';
  2396.         *outp++ = fromY + '1';
  2397.         *outp++ = toX + 'a';
  2398.         *outp++ = toY + '1';
  2399.         *outp++ = ToUpper(promoChar);
  2400.         *outp = NULLCHAR;
  2401.         return BadMove;
  2402.     }
  2403.     else
  2404.       return ret;
  2405.     
  2406.       default:
  2407.     /* Illegal move; use coordinate notation */
  2408.     outp = out;
  2409.     *outp++ = fromX + 'a';
  2410.     *outp++ = fromY + '1';
  2411.     *outp++ = toX + 'a';
  2412.     *outp++ = toY + '1';
  2413.     *outp++ = ToUpper(promoChar);
  2414.     *outp = NULLCHAR;
  2415.     return BadMove;
  2416.     }
  2417. }
  2418.  
  2419.  
  2420. /*
  2421.  * If the user selects on a border boundary, return -1; if off the board,
  2422.  *   return -2.  Otherwise map the event coordinate to the square.
  2423.  */
  2424. int EventToSquare(x)
  2425.      int x;
  2426. {
  2427.     if (x <= 0) 
  2428.       return -2;
  2429.     if (x < LINE_GAP)
  2430.       return -1;
  2431.     x -= LINE_GAP;
  2432.     if ((x % (squareSize + LINE_GAP)) >= squareSize)
  2433.       return -1;
  2434.     x /= (squareSize + LINE_GAP);
  2435.     if (x >= BOARD_SIZE)
  2436.       return -2;
  2437.     return x;
  2438. }
  2439.  
  2440. void DrawSquare(row, column, piece)
  2441.      int row, column;
  2442.      ChessSquare piece;
  2443. {
  2444.     int square_color, x, y, direction, font_ascent, font_descent;
  2445.     char string[2];
  2446.     XCharStruct overall;
  2447.     
  2448.     if (flipView) {
  2449.     x = LINE_GAP + ((BOARD_SIZE-1)-column) * 
  2450.       (squareSize + LINE_GAP);
  2451.     y = LINE_GAP + row * (squareSize + LINE_GAP);
  2452.     } else {
  2453.     x = LINE_GAP + column * (squareSize + LINE_GAP);
  2454.     y = LINE_GAP + ((BOARD_SIZE-1)-row) * 
  2455.       (squareSize + LINE_GAP);
  2456.     }
  2457.     
  2458.     square_color = ((column + row) % 2) == 1;
  2459.     
  2460.     if (piece == EmptySquare)
  2461.       XFillRectangle(xDisplay, xBoardWindow,
  2462.              square_color ? lightSquareGC : darkSquareGC,
  2463.              x, y, squareSize, squareSize);
  2464.     else if (appData.monoMode) {
  2465.     if (square_color)
  2466.       XCopyPlane(xDisplay, (int) piece < (int) BlackPawn
  2467.              ? *pieceToOutline[(int) piece]
  2468.              : *pieceToSolid[(int) piece],
  2469.              xBoardWindow, bwPieceGC, 0, 0,
  2470.              squareSize, squareSize, x, y, 1);
  2471.     else
  2472.       XCopyPlane(xDisplay, (int) piece < (int) BlackPawn
  2473.              ? *pieceToSolid[(int) piece]
  2474.              : *pieceToOutline[(int) piece],
  2475.              xBoardWindow, wbPieceGC, 0, 0,
  2476.              squareSize, squareSize, x, y, 1);
  2477.     } else {
  2478.     if (square_color)
  2479.       XCopyPlane(xDisplay, *pieceToSolid[(int) piece],
  2480.              xBoardWindow, (int) piece < (int) BlackPawn
  2481.              ? wlPieceGC : blPieceGC, 0, 0,
  2482.              squareSize, squareSize, x, y, 1);
  2483.     else
  2484.       XCopyPlane(xDisplay, *pieceToSolid[(int) piece],
  2485.              xBoardWindow, (int) piece < (int) BlackPawn
  2486.              ? wdPieceGC : bdPieceGC, 0, 0,
  2487.              squareSize, squareSize, x, y, 1);
  2488.     }
  2489.     string[1] = NULLCHAR;
  2490.     if (appData.showCoords && row == (flipView ? 7 : 0)) {
  2491.     string[0] = 'a' + column;
  2492.     XTextExtents(coordFontStruct, string, 1, &direction, 
  2493.              &font_ascent, &font_descent, &overall);
  2494.     if (appData.monoMode) {
  2495.         XDrawImageString(xDisplay, xBoardWindow, coordGC,
  2496.                  x + squareSize - overall.width - 2, 
  2497.                  y + squareSize - font_descent - 1, string, 1);
  2498.     } else {
  2499.         XDrawString(xDisplay, xBoardWindow, coordGC,
  2500.             x + squareSize - overall.width - 2, 
  2501.             y + squareSize - font_descent - 1, string, 1);
  2502.     }
  2503.     }
  2504.     if (appData.showCoords && column == (flipView ? 7 : 0)) {
  2505.     string[0] = '1' + row;
  2506.     XTextExtents(coordFontStruct, string, 1, &direction, 
  2507.              &font_ascent, &font_descent, &overall);
  2508.     if (appData.monoMode) {
  2509.         XDrawImageString(xDisplay, xBoardWindow, coordGC,
  2510.                  x + 2, y + font_ascent + 1, string, 1);
  2511.     } else {
  2512.         XDrawString(xDisplay, xBoardWindow, coordGC,
  2513.             x + 2, y + font_ascent + 1, string, 1);
  2514.     }        
  2515.     }   
  2516. }
  2517.  
  2518. void EventProc(widget, unused, event)
  2519.      Widget widget;
  2520.      caddr_t unused;
  2521.      XEvent *event;
  2522. {
  2523.     if (event->type == MappingNotify) {
  2524.     XRefreshKeyboardMapping((XMappingEvent *) event);
  2525.     return;
  2526.     }
  2527.     
  2528.     if (!XtIsRealized(widget))
  2529.       return;
  2530.     
  2531.     if ((event->type == ButtonPress) || (event->type == ButtonRelease))
  2532.       if (event->xbutton.button != Button1)
  2533.     return;
  2534.     
  2535.     switch (event->type) {
  2536.       case Expose:
  2537.     DrawPosition(widget, event, NULL, NULL);
  2538.     break;
  2539.       default:
  2540.     return;
  2541.     }
  2542. }
  2543.  
  2544. /*
  2545.  * event handler for redrawing the board
  2546.  */
  2547. void DrawPosition(w, event, prms, nprms)
  2548.      Widget w;
  2549.      XEvent *event;
  2550.      String *prms;
  2551.      Cardinal *nprms;
  2552. {
  2553.     Arg args[1];
  2554.     int i, j;
  2555.     static Board lastBoard;
  2556.     static int lastBoardValid = 0;
  2557.     static int lastFlipView = 0;
  2558.     
  2559.     if (!appData.Iconic){
  2560.     XtSetArg(args[0], XtNiconic, False);
  2561.     XtSetValues(shellWidget, args, 1);
  2562.     }
  2563.     
  2564.     /*
  2565.      * It would be simpler to clear the window with XClearWindow()
  2566.      * but this causes a very distracting flicker.
  2567.      */
  2568.     
  2569.     if (event == NULL && lastBoardValid && lastFlipView == flipView) {
  2570.     for (i = 0; i < BOARD_SIZE; i++)
  2571.       for (j = 0; j < BOARD_SIZE; j++)
  2572.         if (boards[currentMove][i][j] != lastBoard[i][j])
  2573.           DrawSquare(i, j, boards[currentMove][i][j]);
  2574.     } else {
  2575.     XDrawSegments(xDisplay, xBoardWindow, lineGC,
  2576.               gridSegments, (BOARD_SIZE + 1) * 2);
  2577.     
  2578.     for (i = 0; i < BOARD_SIZE; i++)
  2579.       for (j = 0; j < BOARD_SIZE; j++)
  2580.         DrawSquare(i, j, boards[currentMove][i][j]);
  2581.     }
  2582.     
  2583.     CopyBoard(lastBoard, boards[currentMove]);
  2584.     lastBoardValid = 1;
  2585.     lastFlipView = flipView;
  2586.     
  2587.     XSync(xDisplay, False);
  2588. }
  2589.  
  2590. void InitPosition(redraw)
  2591.      int redraw;
  2592. {
  2593.     currentMove = forwardMostMove = backwardMostMove = 0;
  2594.     CopyBoard(boards[0], initialPosition);
  2595.     if (redraw)
  2596.       DrawPosition(boardWidget, NULL, NULL, NULL);
  2597. }
  2598.  
  2599. void CopyBoard(to, from)
  2600.      Board to, from;
  2601. {
  2602.     int i, j;
  2603.     
  2604.     for (i = 0; i < BOARD_SIZE; i++)
  2605.       for (j = 0; j < BOARD_SIZE; j++)
  2606.     to[i][j] = from[i][j];
  2607. }
  2608.  
  2609. Boolean CompareBoards(board1, board2)
  2610.      Board board1, board2;
  2611. {
  2612.     int i, j;
  2613.     
  2614.     for (i = 0; i < BOARD_SIZE; i++)
  2615.       for (j = 0; j < BOARD_SIZE; j++) {
  2616.       if (board1[i][j] != board2[i][j])
  2617.         return FALSE;
  2618.     }
  2619.     return TRUE;
  2620. }
  2621.  
  2622. void SendCurrentBoard(fp)
  2623.      FILE *fp;
  2624. {
  2625.     SendBoard(fp, boards[currentMove]);
  2626. }
  2627.  
  2628. void SendBoard(fp, board)
  2629.      FILE *fp;
  2630.      Board board;
  2631. {
  2632.     char message[MSG_SIZ];
  2633.     ChessSquare *bp;
  2634.     int i, j;
  2635.     
  2636.     SendToProgram("edit\n", fp);
  2637.     SendToProgram("#\n", fp);
  2638.     for (i = BOARD_SIZE - 1; i >= 0; i--) {
  2639.     bp = &board[i][0];
  2640.     for (j = 0; j < BOARD_SIZE; j++, bp++) {
  2641.         if ((int) *bp < (int) BlackPawn) {
  2642.         sprintf(message, "%c%c%c\n", PieceToChar(*bp), 
  2643.             'a' + j, '1' + i);
  2644.         SendToProgram(message, fp);
  2645.         }
  2646.     }
  2647.     }
  2648.     
  2649.     SendToProgram("c\n", fp);
  2650.     for (i = BOARD_SIZE - 1; i >= 0; i--) {
  2651.     bp = &board[i][0];
  2652.     for (j = 0; j < BOARD_SIZE; j++, bp++) {
  2653.         if (((int) *bp != (int) EmptySquare)
  2654.         && ((int) *bp >= (int) BlackPawn)) {
  2655.         sprintf(message, "%c%c%c\n", ToUpper(PieceToChar(*bp)),
  2656.             'a' + j, '1' + i);
  2657.         SendToProgram(message, fp);
  2658.         }
  2659.     }
  2660.     }
  2661.     
  2662.     SendToProgram(".\n", fp);
  2663. }
  2664.  
  2665. /*
  2666.  * event handler for parsing user moves
  2667.  */
  2668. void HandleUserMove(w, event, prms, nprms)
  2669.      Widget w;
  2670.      XEvent *event;
  2671.      String *prms;
  2672.      Cardinal *nprms;
  2673. {
  2674.     ChessMove move_type;
  2675.     ChessSquare from_piece;
  2676.     int to_x, to_y;
  2677.     
  2678.     if ((w != boardWidget) || (matchMode != MatchFalse))
  2679.       return;
  2680.     
  2681.     if (promotionUp) {
  2682.     XtPopdown(promotionShell);
  2683.     XtDestroyWidget(promotionShell);
  2684.     promotionUp = False;
  2685.     fromX = fromY = -1;
  2686.     }
  2687.     
  2688.     switch (gameMode) {
  2689.       case EndOfGame:
  2690.       case PlayFromGameFile:
  2691.       case TwoMachinesPlay:
  2692.     return;
  2693.       case MachinePlaysWhite:
  2694.     if (WhiteOnMove(forwardMostMove)) {
  2695.         DisplayMessage("It is not your turn");
  2696.         return;
  2697.     }
  2698.     break;
  2699.       case MachinePlaysBlack:
  2700.     if (!WhiteOnMove(forwardMostMove)) {
  2701.         DisplayMessage("It is not your turn");
  2702.         return;
  2703.     }
  2704.     break;
  2705.       case ForceMoves:
  2706.     if (appData.icsActive) {
  2707.         if (ics_user_moved ||
  2708.         ics_mode == IcsObserving ||
  2709.         ics_mode == IcsIdle)
  2710.           return;
  2711.     } else {
  2712.         forwardMostMove = currentMove;
  2713.     }
  2714.     break;
  2715.       default:
  2716.     break;
  2717.     }
  2718.     
  2719.     if (currentMove != forwardMostMove) {
  2720.     DisplayMessage("Displayed position is not current");
  2721.     return;
  2722.     }
  2723.     
  2724.     switch (event->type) {
  2725.       case ButtonPress:
  2726.     if ((fromX >= 0) || (fromY >= 0))
  2727.       return;
  2728.     if (((fromX = EventToSquare(event->xbutton.x)) < 0) ||
  2729.         ((fromY = EventToSquare(event->xbutton.y)) < 0)) {
  2730.         fromX = fromY = -1;
  2731.         return;
  2732.     }
  2733.     if (flipView)
  2734.       fromX = BOARD_SIZE - 1 - fromX;
  2735.     else
  2736.       fromY = BOARD_SIZE - 1 - fromY;
  2737.     break;
  2738.     
  2739.       case ButtonRelease:
  2740.     if ((fromX < 0) || (fromY < 0)) return;
  2741.     
  2742.     if (((to_x = EventToSquare(event->xbutton.x)) < 0)
  2743.         || ((to_y = EventToSquare(event->xbutton.y)) < 0)) {
  2744.         if (gameMode == EditPosition && (to_x == -2 || to_y == -2)) {
  2745.         boards[0][fromY][fromX] = EmptySquare;
  2746.         DrawPosition(boardWidget, NULL, NULL, NULL);
  2747.         XSync(xDisplay, False);
  2748.         }
  2749.         fromX = fromY = -1;
  2750.         return;
  2751.     }
  2752.     if (flipView)
  2753.       to_x = BOARD_SIZE - 1 - to_x;
  2754.     else
  2755.       to_y = BOARD_SIZE - 1 - to_y;
  2756.     
  2757.     if ((fromX == to_x) && (fromY == to_y)) {
  2758.         fromX = fromY = -1;
  2759.         return;
  2760.     }
  2761.     
  2762.     if (gameMode == EditPosition) {
  2763.         boards[0][to_y][to_x] = boards[0][fromY][fromX];
  2764.         boards[0][fromY][fromX] = EmptySquare;
  2765.         fromX = fromY = -1;
  2766.         DrawPosition(boardWidget, NULL, NULL, NULL);
  2767.         XSync(xDisplay, False);
  2768.         return;
  2769.     }
  2770.     
  2771.     from_piece = boards[currentMove][fromY][fromX];
  2772.     if (from_piece == EmptySquare) {
  2773.         fromX = fromY = -1;
  2774.         return;
  2775.     }
  2776.     if (WhiteOnMove(currentMove)) {
  2777.         if ((int)from_piece < (int)WhitePawn ||
  2778.         (int)from_piece > (int)WhiteKing) {
  2779.         DisplayMessage("It is White's turn");
  2780.         fromX = fromY = -1;
  2781.         return;
  2782.         }
  2783.     } else {
  2784.         if ((int)from_piece < (int)BlackPawn ||
  2785.         (int)from_piece > (int)BlackKing) {
  2786.         DisplayMessage("It is Black's turn");
  2787.         fromX = fromY = -1;
  2788.         return;
  2789.         }
  2790.     }
  2791.     if (((from_piece == WhitePawn && to_y == 7) ||
  2792.          (from_piece == BlackPawn && to_y == 0))) {
  2793.         PromotionPopUp(from_piece, to_x, to_y);
  2794.         return;
  2795.     }
  2796.     move_type = LegalityTest(WhiteOnMove(currentMove),
  2797.                  boards[currentMove], fromY, fromX,
  2798.                  to_y, to_x, NULLCHAR);
  2799.     if (move_type == BadMove) {
  2800.         DisplayMessage("Illegal move");
  2801.         fromX = fromY = -1;
  2802.         return;
  2803.     }
  2804.     MakeMove(&move_type, fromX, fromY, to_x, to_y);
  2805.     FinishUserMove(move_type, to_x, to_y);
  2806.     break;
  2807.     }
  2808. }
  2809.  
  2810. void FinishUserMove(move_type, to_x, to_y)
  2811.      ChessMove move_type;
  2812.      int to_x, to_y;
  2813. {
  2814.     char user_move[MSG_SIZ];
  2815.     char promoChar;
  2816.     
  2817.     if (appData.icsActive) {
  2818.     sprintf(user_move, "%c%c%c%c\n",
  2819.         'a' + fromX, '1' + fromY, 'a' + to_x, '1' + to_y);
  2820.     switch (move_type) {
  2821.       default:
  2822.         fprintf(stderr, "%s: internal error; bad move_type\n",
  2823.             programName);
  2824.         break;
  2825.       case WhiteKingSideCastle:
  2826.       case BlackKingSideCastle:
  2827.       case WhiteQueenSideCastleWild:
  2828.       case BlackQueenSideCastleWild:
  2829.         sprintf(user_move, "o-o\n");
  2830.         break;
  2831.       case WhiteQueenSideCastle:
  2832.       case BlackQueenSideCastle:
  2833.       case WhiteKingSideCastleWild:
  2834.       case BlackKingSideCastleWild:
  2835.         sprintf(user_move, "o-o-o\n");
  2836.         break;
  2837.       case WhitePromotionQueen:
  2838.       case BlackPromotionQueen:
  2839.         SendToICS("promote queen\n");
  2840.         break;
  2841.       case WhitePromotionRook:
  2842.       case BlackPromotionRook:
  2843.         SendToICS("promote rook\n");
  2844.         break;
  2845.       case WhitePromotionBishop:
  2846.       case BlackPromotionBishop:
  2847.         SendToICS("promote bishop\n");
  2848.         break;
  2849.       case WhitePromotionKnight:
  2850.       case BlackPromotionKnight:
  2851.         SendToICS("promote knight\n");
  2852.         break;
  2853.       case NormalMove:
  2854.       case WhiteCapturesEnPassant:
  2855.       case BlackCapturesEnPassant:
  2856.         break;
  2857.     }
  2858.     SendToICS(user_move);
  2859.     ics_user_moved = 1;
  2860.     } else {
  2861.     promoChar = ToLower(PieceToChar(PromoPiece(move_type)));
  2862.     if (promoChar == '.')
  2863.       sprintf(user_move, "%c%c%c%c\n",
  2864.           'a' + fromX, '1' + fromY, 'a' + to_x, '1' + to_y);
  2865.     else
  2866.       sprintf(user_move, "%c%c%c%c%c\n",
  2867.           'a' + fromX, '1' + fromY, 'a' + to_x, '1' + to_y,
  2868.           promoChar);
  2869.     
  2870.     Attention(firstProgramPID);
  2871.     if (firstSendTime)
  2872.       SendTimeRemaining(toFirstProgFP);
  2873.     SendToProgram(user_move, toFirstProgFP);
  2874.     }
  2875.     
  2876.     fromX = fromY = -1;
  2877.     
  2878.     strcpy(moveList[currentMove - 1], user_move);
  2879.     
  2880.     /* A user move restarts a paused game*/
  2881.     if (gameMode == PauseGame)
  2882.       PauseProc(NULL, NULL, NULL, NULL);
  2883.     
  2884.     switch (gameMode) {
  2885.       case ForceMoves:
  2886.     break;
  2887.       case PlayFromGameFile:
  2888.     ForceProc(NULL, NULL, NULL, NULL);
  2889.     break;
  2890.       case BeginningOfGame:
  2891.     if (appData.noChessProgram)
  2892.       lastGameMode = gameMode = ForceMoves;
  2893.     else
  2894.       lastGameMode = gameMode = MachinePlaysBlack;
  2895.     ModeHighlight();
  2896.     break;
  2897.       case MachinePlaysBlack:
  2898.       case MachinePlaysWhite:
  2899.       default:
  2900.     break;
  2901.     }
  2902. }
  2903.  
  2904. /* Parser for moves from gnuchess or ICS */
  2905. void ParseMachineMove(machine_move, move_num,
  2906.               move_type, from_x, from_y, to_x, to_y, promo_char)
  2907.      char *machine_move;
  2908.      int move_num;
  2909.      ChessMove *move_type;
  2910.      int *from_x, *from_y, *to_x, *to_y;
  2911.      char *promo_char;
  2912. {       
  2913.     *move_type = yylexstr(move_num, machine_move, NULL);
  2914.     switch (*move_type) {
  2915.       case WhitePromotionQueen:
  2916.       case BlackPromotionQueen:
  2917.       case WhitePromotionRook:
  2918.       case BlackPromotionRook:
  2919.       case WhitePromotionBishop:
  2920.       case BlackPromotionBishop:
  2921.       case WhitePromotionKnight:
  2922.       case BlackPromotionKnight:
  2923.       case NormalMove:
  2924.       case WhiteCapturesEnPassant:
  2925.       case BlackCapturesEnPassant:
  2926.       case WhiteKingSideCastle:
  2927.       case WhiteQueenSideCastle:
  2928.       case BlackKingSideCastle:
  2929.       case BlackQueenSideCastle:
  2930.       case WhiteKingSideCastleWild:
  2931.       case WhiteQueenSideCastleWild:
  2932.       case BlackKingSideCastleWild:
  2933.       case BlackQueenSideCastleWild:
  2934.     *from_x = currentMoveString[0] - 'a';
  2935.     *from_y = currentMoveString[1] - '1';
  2936.     *to_x = currentMoveString[2] - 'a';
  2937.     *to_y = currentMoveString[3] - '1';
  2938.     *promo_char = currentMoveString[4];
  2939.     break;
  2940.       case BadMove:
  2941.       case AmbiguousMove:
  2942.       case 0:            /* end of file */
  2943.       case ElapsedTime:
  2944.       case Comment:
  2945.       case StartGame:
  2946.       case WhiteWins:
  2947.       case BlackWins:
  2948.       case GameIsDrawn:
  2949.       default:
  2950.     /* bug? */
  2951.     fprintf(stderr, "%s: bad move in chess program output: %s\n",
  2952.         programName, machine_move);
  2953.     *from_x = *from_y = *to_x = *to_y = 0;
  2954.     break;
  2955.     }
  2956. }
  2957.  
  2958. void HandleMachineMove(message, fp)
  2959.      char *message;
  2960.      FILE *fp;
  2961. {
  2962.     char machine_move[MSG_SIZ], buf1[MSG_SIZ], buf2[MSG_SIZ];
  2963.     int from_x, from_y, to_x, to_y;
  2964.     ChessMove move_type;
  2965.     char promo_char;
  2966.     
  2967.     maybeThinking = False;
  2968.     
  2969.     if (strncmp(message, "warning:", 8) == 0) {
  2970.     DisplayMessage(message);
  2971.     return;
  2972.     }
  2973.     
  2974.     /*
  2975.      * If chess program startup fails, exit with an error message.
  2976.      * Attempts to recover here are futile.
  2977.      */
  2978.     if ((StrStr(message, "unknown host") != NULL)
  2979.     || (StrStr(message, "No remote directory") != NULL)
  2980.     || (StrStr(message, "not found") != NULL)
  2981.     || (StrStr(message, "No such file") != NULL)
  2982.     || (StrStr(message, "Permission denied") != NULL)) {
  2983.     fprintf(stderr,
  2984.         "%s: failed to start chess program %s on %s: %s\n",
  2985.         programName,
  2986.         fp == fromFirstProgFP ? appData.firstChessProgram
  2987.         : appData.secondChessProgram,
  2988.         fp == fromFirstProgFP ? appData.firstHost
  2989.         : appData.secondHost,
  2990.         message);
  2991.     ShutdownChessPrograms(message);
  2992.     exit(1);
  2993.     }
  2994.     
  2995.     if (strncmp(message, "time", 4) == 0) {
  2996.     if (StrStr(message, "CHESS")) {
  2997.         /* Program has a broken "time" command that
  2998.            outputs a string not ending in newline.
  2999.            Don't use it. */
  3000.         if (fp == fromFirstProgFP) firstSendTime = 0;
  3001.         if (fp == fromSecondProgFP) secondSendTime = 0;
  3002.     }
  3003.     }
  3004.     
  3005.     /*
  3006.      * If the move is illegal, cancel it and redraw the board.
  3007.      */
  3008.     if (strncmp(message, "Illegal move", 12) == 0) {
  3009.     
  3010.     if (fp == fromFirstProgFP && firstSendTime == 2) {
  3011.         /* First program doesn't have the "time" command */
  3012.         firstSendTime = 0;
  3013.         return;
  3014.     } else if (fp == fromSecondProgFP && secondSendTime == 2) {
  3015.         /* Second program doesn't have the "time" command */
  3016.         secondSendTime = 0;
  3017.         return;
  3018.     }
  3019.     if (forwardMostMove <= backwardMostMove) return;
  3020.     if (gameMode == PauseGame) PauseProc(NULL, NULL, NULL, NULL);
  3021.     if (gameMode == PlayFromGameFile) {
  3022.         /* Stop reading this game file */
  3023.         gameMode = ForceMoves;
  3024.         ModeHighlight();
  3025.     }
  3026.     currentMove = --forwardMostMove;
  3027.     if ((gameMode == PlayFromGameFile) || (gameMode == ForceMoves))
  3028.       DisplayClocks(ReDisplayTimers);
  3029.     else
  3030.       DisplayClocks(SwitchTimers);
  3031.     sprintf(buf1, "Illegal move: %s", parseList[currentMove]);
  3032.     DisplayMessage(buf1);
  3033.     
  3034.     DrawPosition(boardWidget, NULL, NULL, NULL);
  3035.     
  3036.     XSync(xDisplay, False);
  3037.     return;
  3038.     }
  3039.     
  3040.     if (strncmp(message, "Hint:", 5) == 0) {
  3041.     sscanf(message, "Hint: %s", machine_move);
  3042.     ParseMachineMove(machine_move, forwardMostMove, &move_type,
  3043.              &from_x, &from_y, &to_x, &to_y, &promo_char);
  3044.     move_type = CoordsToAlgebraic(from_x, from_y, to_x, to_y, promo_char,
  3045.                       forwardMostMove, buf1);
  3046.     sprintf(buf2, "Hint: %s", buf1);
  3047.     DisplayMessage(buf2);
  3048.     return;
  3049.     }
  3050.     
  3051.     /*
  3052.      * win, lose or draw
  3053.      */
  3054.     if (strncmp(message, "White", 5) == 0) {
  3055.     ShutdownChessPrograms("White mates");
  3056.     return;
  3057.     } else if (strncmp(message, "Black", 5) == 0) {
  3058.     ShutdownChessPrograms("Black mates");
  3059.     return;
  3060.     } else if (strncmp(message, "opponent mates!", 15) == 0) {
  3061.     switch (gameMode == PauseGame ? pausePreviousMode : gameMode) {
  3062.       case MachinePlaysBlack:
  3063.         ShutdownChessPrograms("White mates");
  3064.         break;
  3065.       case MachinePlaysWhite:
  3066.         ShutdownChessPrograms("Black mates");
  3067.         break;
  3068.       case TwoMachinesPlay:
  3069.         ShutdownChessPrograms(fp == fromFirstProgFP ?
  3070.                   "White mates" : "Black mates");
  3071.         break;
  3072.       default:
  3073.         /* can't happen */
  3074.         break;
  3075.     }
  3076.     return;
  3077.     } else if (strncmp(message, "computer mates!", 15) == 0) {
  3078.     switch (gameMode == PauseGame ? pausePreviousMode : gameMode) {
  3079.       case MachinePlaysBlack:
  3080.         ShutdownChessPrograms("Black mates");
  3081.         break;
  3082.       case MachinePlaysWhite:
  3083.         ShutdownChessPrograms("White mates");
  3084.         break;
  3085.       case TwoMachinesPlay:
  3086.         ShutdownChessPrograms(fp == fromFirstProgFP ?
  3087.                   "Black mates" : "White mates");
  3088.         break;
  3089.       default:
  3090.         /* can't happen */
  3091.         break;
  3092.     }
  3093.     return;
  3094.     } else if (strncmp(message, "Draw", 4) == 0) {
  3095.     ShutdownChessPrograms("Draw");
  3096.     return;
  3097.     }
  3098.     
  3099.     /*
  3100.      * normal machine reply move
  3101.      */
  3102.     maybeThinking = True;
  3103.     if (StrStr(message, "...") != NULL) {
  3104.     sscanf(message, "%s %s %s", buf1, buf2, machine_move);
  3105.     if (machine_move[0] == NULLCHAR)
  3106.       return;
  3107.     } else
  3108.       return;        /* ignore noise */
  3109.     
  3110.     strcpy(moveList[forwardMostMove], machine_move);
  3111.     
  3112.     ParseMachineMove(machine_move, forwardMostMove, &move_type,
  3113.              &from_x, &from_y, &to_x, &to_y, &promo_char);
  3114.     
  3115.     if (gameMode != PauseGame)
  3116.       currentMove = forwardMostMove;  /*display latest move*/
  3117.     
  3118.     MakeMove(&move_type, from_x, from_y, to_x, to_y);
  3119.     
  3120.     if (gameMode != PauseGame && appData.ringBellAfterMoves)
  3121.       putc(BELLCHAR, stderr);
  3122.     
  3123.     if (gameMode == TwoMachinesPlay ||
  3124.     (gameMode == PauseGame && pausePreviousMode == TwoMachinesPlay)) {
  3125.     strcat(machine_move, "\n");
  3126.     if (WhiteOnMove(forwardMostMove)) {
  3127.         Attention(secondProgramPID);
  3128.         if (secondSendTime) 
  3129.           SendTimeRemaining(toSecondProgFP);
  3130.         SendToProgram(machine_move, toSecondProgFP);
  3131.         if (firstMove) {
  3132.         firstMove = False;
  3133.         SendToProgram(appData.whiteString,
  3134.                   toSecondProgFP);
  3135.         }
  3136.     } else {
  3137.         Attention(firstProgramPID);
  3138.         if (firstSendTime)
  3139.           SendTimeRemaining(toFirstProgFP);
  3140.         SendToProgram(machine_move, toFirstProgFP);
  3141.         if (firstMove) {
  3142.         firstMove = False;
  3143.         SendToProgram(appData.blackString,
  3144.                   toFirstProgFP);
  3145.         }
  3146.     }
  3147.     }
  3148. }
  3149.  
  3150.  
  3151. /* Parse a game score from the character string "game", and
  3152.    record it as the history of the current game.  The game
  3153.    score is NOT assumed to start from the standard position. 
  3154.    The display is not updated in any way.
  3155.    */
  3156. void ParseGameHistory(game)
  3157.      char *game;
  3158. {
  3159.     ChessMove move_type;
  3160.     int from_x, from_y, to_x, to_y, boardIndex;
  3161.     char promo_char;
  3162.     char *p;
  3163.  
  3164.     if (appData.debugMode)
  3165.       fprintf(stderr, "Parsing game history: %s\n", game);
  3166.  
  3167.     /* Parse out names of players */
  3168.     while (*game == ' ') game++;
  3169.     p = ics_white;
  3170.     while (*game != ' ') *p++ = *game++;
  3171.     *p = NULLCHAR;
  3172.     while (*game == ' ') game++;
  3173.     p = ics_black;
  3174.     while (*game != ' ' && *game != '\n') *p++ = *game++;
  3175.     *p = NULLCHAR;
  3176.  
  3177.     /* Parse moves */
  3178.     boardIndex = 0;
  3179.     for (;;) {
  3180.     move_type = yylexstr(boardIndex, game, &game);
  3181.     switch (move_type) {
  3182.       case WhitePromotionQueen:
  3183.       case BlackPromotionQueen:
  3184.       case WhitePromotionRook:
  3185.       case BlackPromotionRook:
  3186.       case WhitePromotionBishop:
  3187.       case BlackPromotionBishop:
  3188.       case WhitePromotionKnight:
  3189.       case BlackPromotionKnight:
  3190.       case NormalMove:
  3191.       case WhiteCapturesEnPassant:
  3192.       case BlackCapturesEnPassant:
  3193.       case WhiteKingSideCastle:
  3194.       case WhiteQueenSideCastle:
  3195.       case BlackKingSideCastle:
  3196.       case BlackQueenSideCastle:
  3197.       case WhiteKingSideCastleWild:
  3198.       case WhiteQueenSideCastleWild:
  3199.       case BlackKingSideCastleWild:
  3200.       case BlackQueenSideCastleWild:
  3201.         from_x = currentMoveString[0] - 'a';
  3202.         from_y = currentMoveString[1] - '1';
  3203.         to_x = currentMoveString[2] - 'a';
  3204.         to_y = currentMoveString[3] - '1';
  3205.         promo_char = currentMoveString[4];
  3206.         break;
  3207.       case BadMove:
  3208.       case AmbiguousMove:
  3209.         /* bug? */
  3210.         fprintf(stderr, "%s: ?bad move in ICS output: %s\n",
  3211.             programName, yytext);
  3212.         /* fall thru */
  3213.       case 0:    /* end of file */
  3214.         if (boardIndex < backwardMostMove) {
  3215.         /* Oops, gap.  How did that happen? */
  3216.         return;
  3217.         }
  3218.         backwardMostMove = 0;
  3219.         if (boardIndex > forwardMostMove) {
  3220.         forwardMostMove = boardIndex;
  3221.         }
  3222.         return;
  3223.       case ElapsedTime:
  3224.         if (boardIndex > 0) {
  3225.         strcat(parseList[boardIndex-1], " ");
  3226.         strcat(parseList[boardIndex-1], yytext);
  3227.         }
  3228.         continue;
  3229.       case Comment:
  3230.       case StartGame:
  3231.       default:
  3232.         /* ignore */
  3233.         continue;
  3234.       case WhiteWins:
  3235.       case BlackWins:
  3236.       case GameIsDrawn:
  3237.         strncpy(endMessage, yytext, MOVE_LEN * 4);
  3238.         endMessage[MOVE_LEN * 4 - 1] = NULLCHAR;
  3239.         continue;
  3240.     }
  3241.     (void) CoordsToAlgebraic(from_x, from_y, to_x, to_y, promo_char,
  3242.                  boardIndex, parseList[boardIndex]);
  3243.     CopyBoard(boards[boardIndex + 1], boards[boardIndex]);
  3244.     boardIndex++;
  3245.     ApplyMove(&move_type, from_x, from_y, to_x, to_y,
  3246.           boards[boardIndex]);
  3247.     }
  3248. }
  3249.  
  3250. void LoadGameLoop()
  3251. {
  3252.     readGameXID = 0;
  3253.     for (;;) {
  3254.     if (!LoadGameOneMove())
  3255.       return;
  3256.     if (matchMode == MatchOpening || appData.timeDelay == 0)
  3257.       continue;
  3258.     if (appData.timeDelay < 0)
  3259.       return;
  3260.     readGameXID =
  3261.       XtAppAddTimeOut(appContext, (int) (1000 * appData.timeDelay),
  3262.               (XtTimerCallbackProc) LoadGameLoop, NULL);
  3263.     break;
  3264.     }
  3265. }
  3266.  
  3267. Boolean LoadGameOneMove()
  3268. {
  3269.     int from_x, from_y, to_x, to_y, done;
  3270.     ChessMove move_type;
  3271.     char move[MSG_SIZ];
  3272.     
  3273.     if (gameFileFP == NULL)
  3274.       return False;
  3275.     
  3276.     if (!(gameMode == PlayFromGameFile ||
  3277.       (gameMode == PauseGame && pausePreviousMode == PlayFromGameFile))) {
  3278.     fclose(gameFileFP);
  3279.     gameFileFP = NULL;
  3280.     yynewfile();
  3281.     return False;
  3282.     }
  3283.     
  3284.     if (commentUp) CommentPopDown();
  3285.     
  3286.     yyboardindex = forwardMostMove;
  3287.     move_type = (ChessMove) yylex();
  3288.     
  3289.     if (appData.debugMode) {
  3290.     switch (move_type) {
  3291.       case BadMove:
  3292.         fprintf(stderr, "Parsed BadMove: %s\n", yytext);
  3293.         break;
  3294.       case AmbiguousMove:
  3295.         fprintf(stderr, "Parsed AmbiguousMove: %s\n", yytext);
  3296.         break;
  3297.       case Comment:
  3298.         fprintf(stderr, "Parsed Comment: %s\n", yytext);
  3299.         break;
  3300.       case WhiteWins:
  3301.       case BlackWins:
  3302.       case GameIsDrawn:
  3303.       case 0:
  3304.         fprintf(stderr, "Parsed game end: %s\n", yytext);
  3305.         break;
  3306.       case StartGame:
  3307.         fprintf(stderr, "Parsed StartGame: %s\n", yytext);
  3308.         break;
  3309.       case ElapsedTime:
  3310.         fprintf(stderr, "Parsed ElapsedTime: %s\n", yytext);
  3311.         break;
  3312.       default:
  3313.         fprintf(stderr, "Parsed %s into %s", yytext, currentMoveString);
  3314.         break;
  3315.     }
  3316.     }
  3317.     
  3318.     done = False;
  3319.     switch (move_type) {
  3320.       case Comment:
  3321.     CommentPopUp(yytext);
  3322.     return True;
  3323.       case WhiteCapturesEnPassant:
  3324.       case BlackCapturesEnPassant:
  3325.       case WhitePromotionQueen:
  3326.       case BlackPromotionQueen:
  3327.       case WhitePromotionRook:
  3328.       case BlackPromotionRook:
  3329.       case WhitePromotionBishop:
  3330.       case BlackPromotionBishop:
  3331.       case WhitePromotionKnight:
  3332.       case BlackPromotionKnight:
  3333.       case NormalMove:
  3334.       case WhiteKingSideCastle:
  3335.       case WhiteQueenSideCastle:
  3336.       case BlackKingSideCastle:
  3337.       case BlackQueenSideCastle:
  3338.       case WhiteKingSideCastleWild:
  3339.       case WhiteQueenSideCastleWild:
  3340.       case BlackKingSideCastleWild:
  3341.       case BlackQueenSideCastleWild:
  3342.     from_x = currentMoveString[0] - 'a';
  3343.     from_y = currentMoveString[1] - '1';
  3344.     to_x = currentMoveString[2] - 'a';
  3345.     to_y = currentMoveString[3] - '1';
  3346.     break;
  3347.       case 0:  /* end of file */
  3348.     DisplayMessage("End of game file");
  3349.     done = True;
  3350.     break;
  3351.       case WhiteWins:
  3352.       case BlackWins:
  3353.       case GameIsDrawn:
  3354.     GameEnds(yytext);
  3355.     return False;
  3356.       case StartGame:
  3357. #ifdef notdef
  3358.     /* We see too many bogus StartGame markers with current
  3359.        lex definition, especially in gnuchess listing files,
  3360.        so this code is disabled. */
  3361.     /* Reached start of next game in file */
  3362.     DisplayMessage("End of game");
  3363.     done = True;
  3364. #else /*!notdef*/
  3365.     /* ignore */
  3366.     return LoadGameOneMove(); /* tail recursion */
  3367. #endif /*notdef*/
  3368.     break;
  3369.       case ElapsedTime:
  3370.     /* ignore */
  3371.     return LoadGameOneMove(); /* tail recursion */
  3372.       default:
  3373.       case BadMove:
  3374.     sprintf(move, "Bad move: %d. %s%s",
  3375.         (forwardMostMove / 2) + 1,
  3376.         WhiteOnMove(forwardMostMove) ? "" : "... ", yytext);
  3377.     DisplayMessage(move);
  3378.     done = True;
  3379.     break;
  3380.       case AmbiguousMove:
  3381.     sprintf(move, "Ambiguous move: %d. %s%s",
  3382.         (forwardMostMove / 2) + 1,
  3383.         WhiteOnMove(forwardMostMove) ? "" : "... ", yytext);
  3384.     DisplayMessage(move);
  3385.     done = True;
  3386.     break;
  3387.     }
  3388.     
  3389.     if (done) {
  3390.     lastGameMode = (gameMode == PauseGame ? pausePreviousMode : gameMode);
  3391.     gameMode = ForceMoves;
  3392.     ModeHighlight();
  3393.     if (readGameXID != 0) {
  3394.         XtRemoveTimeOut(readGameXID);
  3395.         readGameXID = 0;
  3396.     }
  3397.     fclose(gameFileFP);
  3398.     gameFileFP = NULL;
  3399.     yynewfile();
  3400.     return (int) False;
  3401.     } else {
  3402.     SendToProgram(currentMoveString, toFirstProgFP);
  3403.     strcpy(moveList[forwardMostMove], currentMoveString);
  3404.     
  3405.     MakeMove(&move_type, from_x, from_y, to_x, to_y);
  3406.     
  3407.     return (int) True;
  3408.     }
  3409. }
  3410.  
  3411. /* Apply a move to the given board.  Oddity: move_type is ignored on
  3412.    input unless the move is seen to be a pawn promotion, in which case
  3413.    move_type tells us what to promote to.
  3414. */
  3415. void ApplyMove(move_type, from_x, from_y, to_x, to_y, board)
  3416.      ChessMove *move_type;
  3417.      int from_x, from_y, to_x, to_y;
  3418.      Board board;
  3419. {
  3420.     if (from_y == 0 && from_x == 4
  3421.     && board[from_y][from_x] == WhiteKing
  3422.     && to_y == 0 && to_x == 6) {
  3423.     *move_type = WhiteKingSideCastle;
  3424.     board[from_y][from_x] = EmptySquare;
  3425.     board[to_y][to_x] = WhiteKing;
  3426.     board[from_y][7] = EmptySquare;
  3427.     board[to_y][5] = WhiteRook;
  3428.     } else if (from_y == 0 && from_x == 4
  3429.            && board[from_y][from_x] == WhiteKing
  3430.            && to_y == 0 && to_x == 2) {
  3431.     *move_type = WhiteQueenSideCastle;
  3432.     board[from_y][from_x] = EmptySquare;
  3433.     board[to_y][to_x] = WhiteKing;
  3434.     board[from_y][0] = EmptySquare;
  3435.     board[to_y][3] = WhiteRook;
  3436.     } else if (from_y == 0 && from_x == 3
  3437.     && board[from_y][from_x] == WhiteKing
  3438.     && to_y == 0 && to_x == 5) {
  3439.     *move_type = WhiteKingSideCastleWild;
  3440.     board[from_y][from_x] = EmptySquare;
  3441.     board[to_y][to_x] = WhiteKing;
  3442.     board[from_y][7] = EmptySquare;
  3443.     board[to_y][4] = WhiteRook;
  3444.     } else if (from_y == 0 && from_x == 3
  3445.            && board[from_y][from_x] == WhiteKing
  3446.            && to_y == 0 && to_x == 1) {
  3447.     *move_type = WhiteQueenSideCastleWild;
  3448.     board[from_y][from_x] = EmptySquare;
  3449.     board[to_y][to_x] = WhiteKing;
  3450.     board[from_y][0] = EmptySquare;
  3451.     board[to_y][2] = WhiteRook;
  3452.     } else if (from_y == 6
  3453.            && board[from_y][from_x] == WhitePawn
  3454.            && to_y == 7) {
  3455.     /* white pawn promotion */
  3456.     board[7][to_x] = PromoPiece(*move_type);
  3457.     if (board[7][to_x] == EmptySquare) {
  3458.         board[7][to_x] = WhiteQueen;
  3459.         *move_type = WhitePromotionQueen;
  3460.     }
  3461.     board[6][from_x] = EmptySquare;
  3462.     } else if ((from_y == 4)
  3463.            && (to_x != from_x)
  3464.            && (board[from_y][from_x] == WhitePawn)
  3465.            && (board[to_y][to_x] == EmptySquare)) {
  3466.     *move_type = WhiteCapturesEnPassant;
  3467.     board[from_y][from_x] = EmptySquare;
  3468.     board[to_y][to_x] = WhitePawn;
  3469.     board[to_y - 1][to_x] = EmptySquare;
  3470.     } else if (from_y == 7 && from_x == 4
  3471.            && board[from_y][from_x] == BlackKing
  3472.            && to_y == 7 && to_x == 6) {
  3473.     *move_type = BlackKingSideCastle;
  3474.     board[from_y][from_x] = EmptySquare;
  3475.     board[to_y][to_x] = BlackKing;
  3476.     board[from_y][7] = EmptySquare;
  3477.     board[to_y][5] = BlackRook;
  3478.     } else if (from_y == 7 && from_x == 4
  3479.            && board[from_y][from_x] == BlackKing
  3480.            && to_y == 7 && to_x == 2) {
  3481.     *move_type = BlackQueenSideCastle;
  3482.     board[from_y][from_x] = EmptySquare;
  3483.     board[to_y][to_x] = BlackKing;
  3484.     board[from_y][0] = EmptySquare;
  3485.     board[to_y][3] = BlackRook;
  3486.     } else if (from_y == 7 && from_x == 3
  3487.            && board[from_y][from_x] == BlackKing
  3488.            && to_y == 7 && to_x == 5) {
  3489.     *move_type = BlackKingSideCastleWild;
  3490.     board[from_y][from_x] = EmptySquare;
  3491.     board[to_y][to_x] = BlackKing;
  3492.     board[from_y][7] = EmptySquare;
  3493.     board[to_y][4] = BlackRook;
  3494.     } else if (from_y == 7 && from_x == 3
  3495.            && board[from_y][from_x] == BlackKing
  3496.            && to_y == 7 && to_x == 1) {
  3497.     *move_type = BlackQueenSideCastleWild;
  3498.     board[from_y][from_x] = EmptySquare;
  3499.     board[to_y][to_x] = BlackKing;
  3500.     board[from_y][0] = EmptySquare;
  3501.     board[to_y][2] = BlackRook;
  3502.     } else if (from_y == 1
  3503.            && board[from_y][from_x] == BlackPawn
  3504.            && to_y == 0) {
  3505.     /* black pawn promotion */
  3506.     board[0][to_x] = PromoPiece(*move_type);
  3507.     if (board[0][to_x] == EmptySquare) {
  3508.         board[0][to_x] = BlackQueen;
  3509.         *move_type = BlackPromotionQueen;
  3510.     }
  3511.     board[1][from_x] = EmptySquare;
  3512.     } else if ((from_y == 3)
  3513.            && (to_x != from_x)
  3514.            && (board[from_y][from_x] == BlackPawn)
  3515.            && (board[to_y][to_x] == EmptySquare)) {
  3516.     *move_type = BlackCapturesEnPassant;
  3517.     board[from_y][from_x] = EmptySquare;
  3518.     board[to_y][to_x] = BlackPawn;
  3519.     board[to_y + 1][to_x] = EmptySquare;
  3520.     } else {
  3521.     *move_type = NormalMove;
  3522.     board[to_y][to_x] = board[from_y][from_x];
  3523.     board[from_y][from_x] = EmptySquare;
  3524.     }
  3525. }
  3526.  
  3527. /*
  3528.  * MakeMove() displays moves.  If they are illegal, GNU chess will detect
  3529.  * this and send an Illegal move message.  XBoard will then retract the move.
  3530.  *
  3531.  * Oddity: move_type is ignored on input unless the move is seen to be a
  3532.  * pawn promotion, in which case move_type tells us what to promote to.
  3533.  */
  3534. void MakeMove(move_type, from_x, from_y, to_x, to_y)
  3535.      ChessMove *move_type;
  3536.      int from_x, from_y, to_x, to_y;
  3537. {
  3538.     forwardMostMove++;
  3539.     CopyBoard(boards[forwardMostMove], boards[forwardMostMove - 1]);
  3540.     ApplyMove(move_type, from_x, from_y, to_x, to_y,
  3541.           boards[forwardMostMove]);
  3542.     endMessage[0] = NULLCHAR;
  3543.     (void) CoordsToAlgebraic(from_x, from_y, to_x, to_y,
  3544.                  ToLower(PieceToChar(PromoPiece(*move_type))),
  3545.                  forwardMostMove - 1,
  3546.                  parseList[forwardMostMove - 1]);
  3547.     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
  3548.     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
  3549.  
  3550.     if (gameMode == PauseGame && pausePreviousMode != PlayFromGameFile)
  3551.       return;
  3552.     
  3553.     currentMove = forwardMostMove;
  3554.     if ((gameMode == PlayFromGameFile) || (gameMode == ForceMoves) ||
  3555.     (gameMode == PauseGame && pausePreviousMode == PlayFromGameFile))
  3556.       DisplayClocks(ReDisplayTimers);
  3557.     else
  3558.       DisplayClocks(SwitchTimers);
  3559.     DisplayMove(currentMove - 1);
  3560.     DrawPosition(boardWidget, NULL, NULL, NULL);
  3561.     XSync(xDisplay, False);
  3562. }
  3563.  
  3564. void InitChessProgram(host_name, program_name, pid, to, from, xid, sendTime)
  3565.      char *host_name, *program_name;
  3566.      int *pid;
  3567.      FILE **to, **from;
  3568.      XtIntervalId *xid;
  3569.      int *sendTime;
  3570. {
  3571.     char arg_buf[10];
  3572.     char *arg1, *arg2;
  3573.     int to_prog[2], from_prog[2];
  3574.     FILE *from_fp, *to_fp;
  3575.     int dummy_source;
  3576.     XtInputId dummy_id;
  3577. #if defined(SYSTEM_FIVE) || defined(SYSV)
  3578.     char *pty_name;
  3579. #endif
  3580.     
  3581.     if (appData.noChessProgram) return;
  3582.     
  3583. #if defined(SYSTEM_FIVE) || defined(SYSV)
  3584.     if ((pty_name = PseudoTTY(&to_prog[1])) == NULL) {
  3585.     fprintf(stderr, "%s: can't open pseudo-tty: ", programName);
  3586.     perror("");
  3587.     exit(1);
  3588.     }
  3589.     
  3590.     from_prog[0] = to_prog[1];
  3591.     to_prog[0] = from_prog[1] = open(pty_name, O_RDWR, 0);
  3592. #ifdef SVR4
  3593.     if (ioctl (to_prog[0], I_PUSH, "ptem") == -1 ||
  3594.     ioctl (to_prog[0], I_PUSH, "ldterm") == -1 ||
  3595.     ioctl (to_prog[0], I_PUSH, "ttcompat") == -1) {
  3596.     fprintf(stderr, "%s: can't ioctl pseudo-tty: ", programName);
  3597.     perror("");
  3598.     exit(1);
  3599.     }
  3600. #endif
  3601. #else
  3602.     signal(SIGPIPE, CatchPipeSignal);
  3603.     pipe(to_prog);
  3604.     pipe(from_prog);
  3605. #endif
  3606.     
  3607.     if ((*pid = fork()) == 0) {
  3608. #if !defined(SYSTEM_FIVE) && !defined(SYSV)
  3609.     signal(SIGPIPE, CatchPipeSignal);
  3610. #endif
  3611.     dup2(to_prog[0], 0);
  3612.     dup2(from_prog[1], 1);
  3613.     close(to_prog[0]);
  3614.     close(to_prog[1]);
  3615.     close(from_prog[0]);
  3616.     close(from_prog[1]);
  3617.     dup2(1, fileno(stderr)); /* force stderr to the pipe */
  3618.     if (*appData.searchTime != NULLCHAR) {
  3619.         sprintf(arg_buf, "%d", searchTime);
  3620.         arg1 = arg_buf;
  3621.         arg2 = (char *) NULL;
  3622.     } else if (appData.searchDepth > 0) {
  3623.         sprintf(arg_buf, "%d", appData.searchDepth);
  3624.         arg1 = "1";
  3625.         arg2 = "9999";
  3626.     } else {
  3627.         sprintf(arg_buf, "%d", appData.movesPerSession);
  3628.         arg1 = arg_buf;
  3629.         arg2 = appData.timeControl;
  3630.     }
  3631.     if (strcmp(host_name, "localhost") == 0) {
  3632.         execlp(program_name, program_name, arg1, arg2,
  3633.            (char *) NULL);
  3634.     } else {
  3635.         execlp(appData.remoteShell, appData.remoteShell,
  3636.            host_name, program_name, arg1, arg2,
  3637.            (char *) NULL);
  3638.     }
  3639.     
  3640.     perror(program_name);
  3641.     exit(1);
  3642.     }
  3643.     
  3644.     close(to_prog[0]);
  3645.     close(from_prog[1]);
  3646.     
  3647.     *from = from_fp = fdopen(from_prog[0], "r");
  3648.     *to = to_fp = fdopen(to_prog[1], "w");
  3649.     setbuf(from_fp, NULL); setbuf(to_fp, NULL);
  3650.     
  3651.     ReceiveFromProgram(from_fp, &dummy_source, &dummy_id); /*"Chess"*/
  3652.     if (*pid == 0) return;
  3653.     
  3654.     *xid = XtAppAddInput(appContext, fileno(from_fp), 
  3655.              (XtPointer)XtInputReadMask,
  3656.              (XtInputCallbackProc)ReceiveFromProgram, 
  3657.              (XtPointer)from_fp);
  3658.     
  3659.     SendToProgram(appData.initString, to_fp);
  3660.     SendSearchDepth(to_fp);
  3661.     
  3662.     if (*sendTime == 2) {
  3663.     /* Does program have "time" command? */
  3664.     char buf[MSG_SIZ];
  3665.     
  3666.     sprintf(buf, "time %d\nhelp\n", blackTimeRemaining/10);
  3667.     /* "help" is a kludge to work around a gnuchess bug;
  3668.        some versions do not send a newline at the end of
  3669.        their response to the time command */
  3670.     SendToProgram(buf, to_fp);
  3671.     ReceiveFromProgram(from_fp, &dummy_source, &dummy_id);
  3672.     if (*sendTime == 2) *sendTime = 1;  /* yes! */
  3673.     }
  3674.     
  3675. }
  3676.  
  3677. void GameEnds(why)
  3678.      char *why;
  3679. {
  3680.     ics_mode = IcsIdle;
  3681.     ics_gamenum = -1;
  3682.     ics_user_moved = False;
  3683.     if (readGameXID != 0) {
  3684.     XtRemoveTimeOut(readGameXID);
  3685.     readGameXID = 0;
  3686.     }
  3687.     if (gameFileFP != NULL) {
  3688.     fclose(gameFileFP);
  3689.     gameFileFP = NULL;
  3690.     yynewfile();
  3691.     }
  3692.     DisplayClocks(StopTimers);
  3693.     
  3694.     if (why == NULL) return;
  3695.     
  3696.     strncpy(endMessage, why, MOVE_LEN * 4);
  3697.     endMessage[MOVE_LEN * 4 - 1] = NULLCHAR;
  3698.     if (currentMove == forwardMostMove)
  3699.       DisplayMove(currentMove - 1);
  3700.     
  3701.     if (!(gameMode == PlayFromGameFile ||
  3702.       (gameMode == PauseGame && pausePreviousMode == PlayFromGameFile))) {
  3703.     if (*appData.saveGameFile != NULLCHAR) {
  3704.         SaveGame(appData.saveGameFile);
  3705.     } else if (appData.autoSaveGames) {
  3706.         SaveGameProc(NULL, NULL, NULL, NULL);
  3707.     }
  3708.     if (appData.savePositionFile[0] != NULLCHAR) 
  3709.       SavePosition(appData.savePositionFile);
  3710.     }
  3711. }
  3712.  
  3713. void ShutdownChessPrograms(why)
  3714.      char *why;
  3715. {
  3716.     GameEnds(why);
  3717.     
  3718.     lastGameMode = gameMode;
  3719.     if (gameMode == PauseGame) {
  3720.     pausePreviousMode = EndOfGame;
  3721.     } else {
  3722.     gameMode = EndOfGame;
  3723.     ModeHighlight();
  3724.     }
  3725.     
  3726.     if (firstProgramPID != 0) {
  3727.     if (kill(firstProgramPID, 0) == 0)
  3728.       SendToProgram("quit\n", toFirstProgFP);
  3729.     fclose(fromFirstProgFP);
  3730.     fclose(toFirstProgFP);
  3731.     fromFirstProgFP = toFirstProgFP = NULL;
  3732.     if (kill(firstProgramPID, SIGTERM)==0) 
  3733.       wait((union wait *)0);
  3734.     
  3735.     }
  3736.     firstProgramPID = 0;
  3737.     
  3738.     if (firstProgramXID != 0)
  3739.       XtRemoveInput(firstProgramXID);
  3740.     firstProgramXID = 0;
  3741.     
  3742.     if (secondProgramPID != 0) {
  3743.     if (kill(secondProgramPID, 0) == 0)
  3744.       SendToProgram("quit\n", toSecondProgFP);
  3745.     fclose(fromSecondProgFP);
  3746.     fclose(toSecondProgFP);
  3747.     fromSecondProgFP = toSecondProgFP = NULL;
  3748.     if (kill(secondProgramPID, SIGTERM)==0) 
  3749.       wait((union wait *)0);
  3750.     }
  3751.     secondProgramPID = 0;
  3752.     
  3753.     if (secondProgramXID != 0)
  3754.       XtRemoveInput(secondProgramXID);
  3755.     secondProgramXID = 0;
  3756.     
  3757.     if (matchMode != MatchFalse) exit(0);
  3758. }
  3759.  
  3760. void CommentPopDown()
  3761. {
  3762.     Arg args[2];
  3763.     
  3764.     XtSetArg(args[0], XtNx, &commentX);
  3765.     XtSetArg(args[1], XtNy, &commentY);
  3766.     XtGetValues(commentShell, args, 2);
  3767.     XtPopdown(commentShell);
  3768.     XtDestroyWidget(commentShell);
  3769.     commentUp = False;
  3770. }
  3771.  
  3772.  
  3773. void CommentPopUp(label)
  3774.      char *label;
  3775. {
  3776.     Arg args[2];
  3777.     Position x, y;
  3778.     Dimension bw_width, pw_width;
  3779.     
  3780.     if (commentUp) CommentPopDown();
  3781.     
  3782.     XtSetArg(args[0], XtNwidth, &bw_width);
  3783.     XtGetValues(formWidget, args, 1);
  3784.     
  3785.     XtSetArg(args[0], XtNresizable, True);
  3786.     XtSetArg(args[1], XtNwidth, bw_width - 8);
  3787.     
  3788.     commentShell =
  3789.       XtCreatePopupShell("Comment", transientShellWidgetClass,
  3790.              commandsWidget, args, 2);
  3791.     
  3792.     XtSetArg(args[0], XtNlabel, label);
  3793.     
  3794.     (void) XtCreateManagedWidget("commentLabel", labelWidgetClass,
  3795.                  commentShell, args, 1);
  3796.     
  3797.     XtRealizeWidget(commentShell);
  3798.     
  3799.     XtSetArg(args[0], XtNwidth, &pw_width);
  3800.     XtGetValues(commentShell, args, 1);
  3801.     
  3802.     if (commentX == -1) {
  3803.     XtTranslateCoords(shellWidget, (bw_width - pw_width) / 2, -50, &x, &y);
  3804.     } else {
  3805.     x = commentX - appData.borderXoffset;
  3806.     y = commentY - appData.borderYoffset;
  3807.     }
  3808.  
  3809.     XtSetArg(args[0], XtNx, x);
  3810.     XtSetArg(args[1], XtNy, y);
  3811.     XtSetValues(commentShell, args, 2);
  3812.     
  3813.     XtPopup(commentShell, XtGrabNone);
  3814.  
  3815.     commentUp = True;
  3816. }
  3817.  
  3818. void FileNamePopUp(label, def, proc)
  3819.      char *label;
  3820.      char *def;
  3821.      Boolean (*proc) P((char *name));
  3822. {
  3823.     Arg args[2];
  3824.     Widget popup, dialog;
  3825.     Dimension bw_width, pw_width;
  3826.     Window root, child;
  3827.     int x, y;
  3828.     int win_x, win_y;
  3829.     unsigned int mask;
  3830.     
  3831.     fileProc = proc;
  3832.     
  3833.     XtSetArg(args[0], XtNwidth, &bw_width);
  3834.     XtGetValues(boardWidget, args, 1);
  3835.     
  3836.     XtSetArg(args[0], XtNresizable, True);
  3837.     XtSetArg(args[1], XtNwidth, DIALOG_SIZE);
  3838.     
  3839.     popup =
  3840.       XtCreatePopupShell("File Name Prompt", transientShellWidgetClass,
  3841.              commandsWidget, args, 2);
  3842.     
  3843.     XtSetArg(args[0], XtNlabel, label);
  3844.     XtSetArg(args[1], XtNvalue, def);
  3845.     
  3846.     dialog = XtCreateManagedWidget("dialog", dialogWidgetClass,
  3847.                    popup, args, 2);
  3848.     
  3849.     XawDialogAddButton(dialog, "ok", FileNameCallback, (XtPointer) dialog);
  3850.     XawDialogAddButton(dialog, "cancel", FileNameCallback,
  3851.                (XtPointer) dialog);
  3852.     
  3853.     XtRealizeWidget(popup);
  3854.     
  3855.     XtSetArg(args[0], XtNwidth, &pw_width);
  3856.     XtGetValues(popup, args, 1);
  3857.     
  3858.     XQueryPointer(xDisplay, xBoardWindow, &root, &child,
  3859.           &x, &y, &win_x, &win_y, &mask);
  3860.     
  3861.     XtSetArg(args[0], XtNx, x - 10);
  3862.     XtSetArg(args[1], XtNy, y - 10);
  3863.     XtSetValues(popup, args, 2);
  3864.     
  3865.     XtPopup(popup, XtGrabExclusive);
  3866.     filenameUp = True;
  3867.     
  3868.     XtSetKeyboardFocus(shellWidget, popup);
  3869. }
  3870.  
  3871. void FileNameCallback(w, client_data, call_data)
  3872.      Widget w;
  3873.      XtPointer client_data, call_data;
  3874. {
  3875.     String name;
  3876.     Arg args[1];
  3877.     
  3878.     XtSetArg(args[0], XtNlabel, &name);
  3879.     XtGetValues(w, args, 1);
  3880.     
  3881.     if (strcmp(name, "cancel") == 0) {
  3882.     XtPopdown(w = XtParent(XtParent(w)));
  3883.     XtDestroyWidget(w);
  3884.     filenameUp = False;
  3885.     ModeHighlight();
  3886.     return;
  3887.     }
  3888.     
  3889.     FileNameAction(w, NULL, NULL, NULL);
  3890. }
  3891.  
  3892. void FileNameAction(w, event, prms, nprms)
  3893.      Widget w;
  3894.      XEvent *event;
  3895.      String *prms;
  3896.      Cardinal *nprms;
  3897. {
  3898.     char buf[MSG_SIZ];
  3899.     String name;
  3900.  
  3901.     name = XawDialogGetValueString(w = XtParent(w));
  3902.     
  3903.     if ((name != NULL) && (*name != NULLCHAR)) {
  3904.     strcpy(buf, name);
  3905.     XtPopdown(w = XtParent(w));
  3906.     XtDestroyWidget(w);
  3907.     filenameUp = False;
  3908.     (void) (*fileProc)(buf); /* I can't see a way not
  3909.                     to use a global here */
  3910.     ModeHighlight();
  3911.     return;
  3912.     }
  3913.     
  3914.     XtPopdown(w = XtParent(w));
  3915.     XtDestroyWidget(w);
  3916.     filenameUp = False;
  3917.     ModeHighlight();
  3918. }
  3919.  
  3920. typedef struct {
  3921.     ChessSquare piece;
  3922.     int to_x, to_y;
  3923. } PromotionMoveInfo;
  3924.  
  3925. static PromotionMoveInfo pmi;  /*making this global is gross */
  3926.  
  3927. void PromotionPopUp(piece, to_x, to_y)
  3928.      ChessSquare piece;
  3929.      int to_x, to_y;
  3930. {
  3931.     Arg args[2];
  3932.     Widget dialog;
  3933.     Position x, y;
  3934.     Dimension bw_width, bw_height, pw_width, pw_height;
  3935.     
  3936.     pmi.piece = piece;
  3937.     pmi.to_x = to_x;
  3938.     pmi.to_y = to_y;
  3939.     
  3940.     XtSetArg(args[0], XtNwidth, &bw_width);
  3941.     XtSetArg(args[1], XtNheight, &bw_height);
  3942.     XtGetValues(boardWidget, args, 2);
  3943.     
  3944.     XtSetArg(args[0], XtNresizable, True);
  3945.     promotionShell =
  3946.       XtCreatePopupShell("Promotion", transientShellWidgetClass,
  3947.              commandsWidget, args, 1);
  3948.     
  3949.     XtSetArg(args[0], XtNlabel, "Promote pawn to what?");
  3950.     dialog = XtCreateManagedWidget("promotion", dialogWidgetClass,
  3951.                    promotionShell, args, 1);
  3952.     
  3953.     XawDialogAddButton(dialog, "Queen", PromotionCallback, 
  3954.                (XtPointer) dialog);
  3955.     XawDialogAddButton(dialog, "Rook", PromotionCallback, 
  3956.                (XtPointer) dialog);
  3957.     XawDialogAddButton(dialog, "Bishop", PromotionCallback, 
  3958.                (XtPointer) dialog);
  3959.     XawDialogAddButton(dialog, "Knight", PromotionCallback, 
  3960.                (XtPointer) dialog);
  3961.     XawDialogAddButton(dialog, "cancel", PromotionCallback, 
  3962.                (XtPointer) dialog);
  3963.     
  3964.     XtRealizeWidget(promotionShell);
  3965.     
  3966.     XtSetArg(args[0], XtNwidth, &pw_width);
  3967.     XtSetArg(args[1], XtNheight, &pw_height);
  3968.     XtGetValues(promotionShell, args, 2);
  3969.     
  3970.     XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2,
  3971.               LINE_GAP + squareSize/3 +
  3972.               ((piece == WhitePawn) ^ (flipView) ?
  3973.                0 : 6*(squareSize + LINE_GAP)), &x, &y);
  3974.     
  3975.     XtSetArg(args[0], XtNx, x);
  3976.     XtSetArg(args[1], XtNy, y);
  3977.     XtSetValues(promotionShell, args, 2);
  3978.     
  3979.     XtPopup(promotionShell, XtGrabNone);
  3980.     
  3981.     promotionUp = True;
  3982. }
  3983.  
  3984. void PromotionCallback(w, client_data, call_data)
  3985.      Widget w;
  3986.      XtPointer client_data, call_data;
  3987. {
  3988.     String name;
  3989.     Arg args[1];
  3990.     ChessMove move_type;
  3991.     int promoChar;
  3992.     
  3993.     XtSetArg(args[0], XtNlabel, &name);
  3994.     XtGetValues(w, args, 1);
  3995.     
  3996.     XtPopdown(w = XtParent(XtParent(w)));
  3997.     XtDestroyWidget(w);
  3998.     promotionUp = False;
  3999.     
  4000.     if (fromX == -1) return;
  4001.     
  4002.     if (strcmp(name, "cancel") == 0) {
  4003.     fromX = fromY = -1;
  4004.     return;
  4005.     } else if (strcmp(name, "Knight") == 0) {
  4006.     promoChar = 'n';
  4007.     } else {
  4008.     promoChar = ToLower(name[0]);
  4009.     }
  4010.  
  4011.     move_type = LegalityTest(WhiteOnMove(forwardMostMove),
  4012.                  boards[forwardMostMove], fromY, fromX,
  4013.                  pmi.to_y, pmi.to_x, promoChar);
  4014.     if (move_type == BadMove) {
  4015.     DisplayMessage("Illegal move");
  4016.     fromX = fromY = -1;
  4017.     return;
  4018.     }
  4019.     MakeMove(&move_type, fromX, fromY, pmi.to_x, pmi.to_y);
  4020.     FinishUserMove(move_type, pmi.to_x, pmi.to_y);
  4021. }
  4022.  
  4023. void SelectCommand(w, client_data, call_data)
  4024.      Widget w;
  4025.      XtPointer client_data, call_data;
  4026. {
  4027.     XawListReturnStruct *list_return = XawListShowCurrent(w);
  4028.     
  4029.     fromX = fromY = -1;
  4030.     
  4031.     if (promotionUp) {
  4032.     XtPopdown(promotionShell);
  4033.     XtDestroyWidget(promotionShell);
  4034.     promotionUp = False;
  4035.     }
  4036.     
  4037.     (*buttonProcs[list_return->list_index])(w, NULL, NULL, NULL);
  4038.     
  4039.     if (!filenameUp) ModeHighlight();
  4040. }
  4041.  
  4042. void HighlightProcButton(proc)
  4043.      XtActionProc proc;
  4044. {
  4045.     int i = 0;
  4046.     
  4047.     if (proc == NULL) {
  4048.     XawListUnhighlight(commandsWidget);
  4049.     return;
  4050.     }
  4051.     
  4052.     for (;;) {
  4053.     if (buttonProcs[i] == NULL) {
  4054.         XawListUnhighlight(commandsWidget);
  4055.         return;
  4056.     }
  4057.     if (buttonProcs[i] == proc) {
  4058.         XawListHighlight(commandsWidget, i);
  4059.         return;
  4060.     }
  4061.     i++;
  4062.     }
  4063. }
  4064.  
  4065. void ModeHighlight()
  4066. {
  4067.     switch (gameMode) {
  4068.       case BeginningOfGame:
  4069.     if (appData.icsActive)
  4070.       HighlightProcButton(NULL);
  4071.     else if (appData.noChessProgram)
  4072.       HighlightProcButton(ForceProc);
  4073.     else
  4074.       HighlightProcButton(MachineBlackProc);
  4075.     break;
  4076.       case MachinePlaysBlack:
  4077.     HighlightProcButton(MachineBlackProc);
  4078.     break;
  4079.       case MachinePlaysWhite:
  4080.     HighlightProcButton(MachineWhiteProc);
  4081.     break;
  4082.       case TwoMachinesPlay:
  4083.     HighlightProcButton(TwoMachinesProc);
  4084.     break;
  4085.       case ForceMoves:
  4086.     if (appData.icsActive)
  4087.       HighlightProcButton(NULL);
  4088.     else
  4089.       HighlightProcButton(ForceProc);
  4090.     break;
  4091.       case PlayFromGameFile:
  4092.     HighlightProcButton(LoadGameProc);
  4093.     break;
  4094.       case PauseGame:
  4095.     HighlightProcButton(PauseProc);
  4096.     break;
  4097.       case EditPosition:
  4098.     HighlightProcButton(EditPositionProc);
  4099.     break;
  4100.       case EndOfGame:
  4101.       default:
  4102.     HighlightProcButton(NULL);
  4103.     break;
  4104.     }
  4105. }
  4106.  
  4107. /*
  4108.  * Button procedures
  4109.  */
  4110. void QuitProc(w, event, prms, nprms)
  4111.      Widget w;
  4112.      XEvent *event;
  4113.      String *prms;
  4114.      Cardinal *nprms;
  4115. {
  4116.     /* Save game if resource set and not already saved */
  4117.     if (*endMessage == NULLCHAR) {
  4118.     if (appData.saveGameFile[0] != NULLCHAR) 
  4119.       SaveGame(appData.saveGameFile);
  4120.     if (appData.savePositionFile[0] != NULLCHAR) 
  4121.       SavePosition(appData.savePositionFile);
  4122.     }
  4123.     ShutdownChessPrograms(NULL);
  4124.     if (telnetPID != 0) {
  4125.     if (kill(telnetPID, SIGTERM) == 0)
  4126.       wait((union wait *) 0);
  4127.     }
  4128.     exit(0);
  4129. }
  4130.  
  4131. void CallFlagProc(w, event, prms, nprms)
  4132.      Widget w;
  4133.      XEvent *event;
  4134.      String *prms;
  4135.      Cardinal *nprms;
  4136. {
  4137.     /* Call your opponent's flag (claim a win on time) */
  4138.     if (appData.icsActive) {
  4139.     SendToICS("flag\n");
  4140.     } else {
  4141.     switch (gameMode) {
  4142.       default:
  4143.         return;
  4144.       case MachinePlaysWhite:
  4145.         if (whiteFlag) {
  4146.         if (blackFlag)
  4147.           ShutdownChessPrograms("Draw (both players ran out of time)");
  4148.         else
  4149.           ShutdownChessPrograms("Black wins on time");
  4150.         }
  4151.         break;
  4152.       case MachinePlaysBlack:
  4153.         if (blackFlag) {
  4154.         if (whiteFlag)
  4155.           ShutdownChessPrograms("Draw (both players ran out of time)");
  4156.         else
  4157.           ShutdownChessPrograms("White wins on time");
  4158.         }
  4159.         break;
  4160.     }
  4161.     }
  4162. }
  4163.  
  4164. void DrawProc(w, event, prms, nprms)
  4165.      Widget w;
  4166.      XEvent *event;
  4167.      String *prms;
  4168.      Cardinal *nprms;
  4169. {
  4170.     /* Offer draw or accept pending draw offer from opponent */
  4171.     
  4172.     if (appData.icsActive) {
  4173.     /* Note: tournament rules require draw offers to be
  4174.        made after you make your move but before you punch
  4175.        your clock.  Currently ICS doesn't let you do that;
  4176.        instead, you always punch your clock after making a
  4177.        move, but you can offer a draw at any time. */
  4178.     
  4179.     SendToICS("draw\n");
  4180.     } else {
  4181.     /* Currently GNU Chess doesn't offer or accept draws
  4182.        at all, so there is no Draw button in GNU Chess
  4183.        mode.  */
  4184.     
  4185.     fprintf(stderr, "Draw function not implemented\n");
  4186.     }
  4187. }
  4188.  
  4189.  
  4190. void DeclineDrawProc(w, event, prms, nprms)
  4191.      Widget w;
  4192.      XEvent *event;
  4193.      String *prms;
  4194.      Cardinal *nprms;
  4195. {
  4196.     /* Decline a pending draw offer from opponent */
  4197.     
  4198.     if (appData.icsActive) {
  4199.     /* Note: ICS also lets you withdraw your own draw
  4200.        offer with this command.  I'm not sure how long
  4201.        your draw offer remains pending if you don't
  4202.        withdraw it. */
  4203.     
  4204.     SendToICS("decline draw\n");
  4205.     } else {
  4206.     /* Currently GNU Chess doesn't offer or accept draws
  4207.        at all, so there is no Decline Draw button in
  4208.        GNU Chess mode.  */
  4209.     
  4210.     fprintf(stderr, "Decline Draw function not implemented\n");
  4211.     }
  4212. }
  4213.  
  4214.  
  4215. void ResignProc(w, event, prms, nprms)
  4216.      Widget w;
  4217.      XEvent *event;
  4218.      String *prms;
  4219.      Cardinal *nprms;
  4220. {
  4221.     /* Resign.  You can do this even if it's not your turn. */
  4222.     
  4223.     if (appData.icsActive) {
  4224.     SendToICS("resign\n");
  4225.     } else {
  4226.     /* This button is not currently used in GNU Chess mode,
  4227.        but it should work. */
  4228.     
  4229.     switch (gameMode) {
  4230.       case MachinePlaysWhite:
  4231.         ShutdownChessPrograms("Black resigns");
  4232.         break;
  4233.       case MachinePlaysBlack:
  4234.         ShutdownChessPrograms("White resigns");
  4235.         break;
  4236.       default:
  4237.         break;
  4238.     }
  4239.     }
  4240. }
  4241.  
  4242.  
  4243. Boolean LoadGame(name)
  4244.      char *name;
  4245. {
  4246.     char buf[MSG_SIZ], lname[MSG_SIZ];
  4247.     ChessMove cm;
  4248.     int gameNumber;
  4249.     char *p;
  4250.     
  4251.     if (gameMode != BeginningOfGame) {
  4252.     DisplayMessage("Press Reset first");
  4253.     return False;
  4254.     }
  4255.     
  4256.     /* Parse game number if given */
  4257.     strcpy(lname, name);
  4258.     p = strrchr(lname, ' ');
  4259.     if (p == NULL) {
  4260.     gameNumber = 1;
  4261.     } else {
  4262.     *p++ = NULLCHAR;
  4263.     gameNumber = atoi(p);
  4264.     }
  4265.  
  4266.     yynewfile();
  4267.     if ((gameFileFP = fopen(lname, "r")) == NULL) {
  4268.     sprintf(buf, "Can't open %s", lname);
  4269.     DisplayMessage(buf);
  4270.     return False;
  4271.     }
  4272.     
  4273.     p = strrchr(name, '/');
  4274.     if (p == NULL)
  4275.       p = name;
  4276.     else
  4277.       p++;
  4278.     DisplayTitle(p);
  4279.  
  4280.     lastGameMode = gameMode = PlayFromGameFile;
  4281.     ModeHighlight();
  4282.     InitPosition(True);
  4283.     DisplayClocks(StopTimers);
  4284.     if (firstProgramXID == 0) {
  4285.     InitChessProgram(appData.firstHost, appData.firstChessProgram,
  4286.              &firstProgramPID, &toFirstProgFP,
  4287.              &fromFirstProgFP, &firstProgramXID,
  4288.              &firstSendTime);
  4289.     } else {
  4290.     SendToProgram(appData.initString, toFirstProgFP);
  4291.     SendSearchDepth(toFirstProgFP);
  4292.     }
  4293.     SendToProgram("force\n", toFirstProgFP);
  4294.     
  4295.     /*
  4296.      * Skip the first gameNumber-1 games in the file.
  4297.      * Also skip over anything that precedes an identifiable 
  4298.      * StartGame marker, to avoid being confused by 
  4299.      * garbage at the start of the file.  Currently 
  4300.      * recognized StartGame markers are the move number "1",
  4301.      * the pattern "gnuchess .* game", or a position diagram.
  4302.      */
  4303.     cm = StartGame;
  4304.     while (gameNumber > 0) {
  4305.     yyboardindex = forwardMostMove;
  4306.     cm = (ChessMove) yylex();
  4307.     if (cm == (ChessMove) 0) {
  4308.         Reset(True);
  4309.         DisplayMessage("Game not found in file");
  4310.         return False;
  4311.     }
  4312.     if (cm == StartGame || cm == PositionDiagram)
  4313.       gameNumber--;
  4314.     }
  4315.     
  4316.     /* If the file starts with a position diagram,
  4317.        set up the position */
  4318.     if (cm == PositionDiagram) {
  4319.     Board initial_position;
  4320.     int i, j;
  4321.     char *p = yytext;
  4322.     
  4323.     startedFromSetupPosition = True;
  4324.     
  4325.     for (i = BOARD_SIZE - 1; i >= 0; i--)
  4326.       for (j = 0; j < BOARD_SIZE; p++)
  4327.         switch (*p) {
  4328.           case '[':
  4329.           case '-':
  4330.           case ' ':
  4331.           case '\t':
  4332.           case '\n':
  4333.         break;
  4334.           default:
  4335.         initial_position[i][j++] = CharToPiece(*p);
  4336.         break;
  4337.         }
  4338.     
  4339.     while (*p == ' ' || *p == '\t' || *p == '\n') p++;
  4340.     
  4341.     if (strncmp(p, "black", strlen("black"))==0)
  4342.       blackPlaysFirst = True;
  4343.     else
  4344.       blackPlaysFirst = False;
  4345.     
  4346.     if (blackPlaysFirst) {
  4347.         CopyBoard(boards[0], initial_position);
  4348.         strcpy(moveList[0], "");
  4349.         strcpy(parseList[0], "");
  4350.         currentMove = forwardMostMove = backwardMostMove = 1;
  4351.         CopyBoard(boards[1], initial_position);
  4352.         SendToProgram("a3\n", toFirstProgFP);
  4353.         SendCurrentBoard(toFirstProgFP);
  4354.     } else {
  4355.         currentMove = forwardMostMove = backwardMostMove = 0;
  4356.         CopyBoard(boards[0], initial_position);
  4357.         SendCurrentBoard(toFirstProgFP);
  4358.     }
  4359.     
  4360.     DrawPosition(boardWidget, NULL, NULL, NULL);
  4361.     }
  4362.  
  4363.     DisplayClocks(ResetTimers);
  4364.     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
  4365.     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
  4366.  
  4367.     LoadGameLoop();
  4368.     
  4369.     return True;
  4370. }
  4371.  
  4372. void ResurrectChessProgram()
  4373.      /* Get out of EndOfGame mode.  This may require us to restart the
  4374.     chess program and feed it all the moves made so far. */
  4375. {
  4376.     char buf[MSG_SIZ];
  4377.     int i;
  4378.     
  4379.     /* assert(gameMode == EndOfGame) */
  4380.     
  4381.     gameMode = lastGameMode = ForceMoves;
  4382.     ModeHighlight();
  4383.     
  4384.     if (firstProgramPID != 0) return;
  4385.     
  4386.     InitChessProgram(appData.firstHost, appData.firstChessProgram,
  4387.              &firstProgramPID, &toFirstProgFP, &fromFirstProgFP,
  4388.              &firstProgramXID, &firstSendTime);
  4389.     SendToProgram("force\n", toFirstProgFP);
  4390.     
  4391.     if (startedFromSetupPosition) {
  4392.     if (backwardMostMove % 2 == 1)
  4393.       SendToProgram("a3\n", toFirstProgFP);
  4394.     SendBoard(toFirstProgFP, boards[backwardMostMove]);
  4395.     }
  4396.     
  4397.     for (i = backwardMostMove; i < currentMove; i++) {
  4398.     strcpy(buf, moveList[i]);
  4399.     SendToProgram(buf, toFirstProgFP);
  4400.     }
  4401.     
  4402.     if (!firstSendTime) {
  4403.     /* can't tell gnuchess what its clock should read,
  4404.        so we bow to its notion. */
  4405.     DisplayClocks(ResetTimers);
  4406.     timeRemaining[0][currentMove] = whiteTimeRemaining;
  4407.     timeRemaining[1][currentMove] = blackTimeRemaining;
  4408.     }
  4409. }
  4410.  
  4411. void MachineBlackProc(w, event, prms, nprms)
  4412.      Widget w;
  4413.      XEvent *event;
  4414.      String *prms;
  4415.      Cardinal *nprms;
  4416. {
  4417.     if (gameMode == PauseGame) PauseProc(w, event, prms, nprms);
  4418.     if (gameMode == PlayFromGameFile) ForceProc(w, event, prms, nprms);
  4419.     if (gameMode == EditPosition) EditPositionDone();
  4420.     
  4421.     if ((gameMode == EndOfGame) || (gameMode == TwoMachinesPlay) ||
  4422.     (appData.noChessProgram) || (gameMode == MachinePlaysBlack))
  4423.       return;
  4424.     
  4425.     if (WhiteOnMove(gameMode == ForceMoves ? currentMove : forwardMostMove)) {
  4426.     DisplayMessage("It is not Black's turn");
  4427.     return;
  4428.     }
  4429.     
  4430.     if (gameMode == ForceMoves) forwardMostMove = currentMove;
  4431.     
  4432.     lastGameMode = gameMode = MachinePlaysBlack;
  4433.     ModeHighlight();
  4434.     SendToProgram(appData.blackString, toFirstProgFP);
  4435.     DisplayClocks(StartTimers);
  4436. }
  4437.  
  4438. void ForwardProc(w, event, prms, nprms)
  4439.      Widget w;
  4440.      XEvent *event;
  4441.      String *prms;
  4442.      Cardinal *nprms;
  4443. {
  4444.     char buf[MSG_SIZ];
  4445.     int target;
  4446.     unsigned int state;
  4447.     
  4448.     if ((gameMode == EndOfGame) || (gameMode == EditPosition))
  4449.       return;
  4450.     
  4451.     if (gameMode == PlayFromGameFile)
  4452.       PauseProc(w, event, prms, nprms);
  4453.     
  4454.     if (currentMove >= forwardMostMove) {
  4455.     if (gameFileFP != NULL)
  4456.       (void) LoadGameOneMove();
  4457.     return;
  4458.     }
  4459.     
  4460.     if (event == NULL) {
  4461.     /* Kludge */
  4462.     Window root, child;
  4463.     int root_x, root_y;
  4464.     int win_x, win_y;
  4465.     XQueryPointer(xDisplay, xBoardWindow,
  4466.               &root, &child, &root_x, &root_y,
  4467.               &win_x, &win_y, &state);
  4468.     } else {
  4469.     state = event->xkey.state;
  4470.     }
  4471.     
  4472.     if (state & ShiftMask)
  4473.       target = forwardMostMove;
  4474.     else
  4475.       target = currentMove + 1;
  4476.     
  4477.     if (gameMode == ForceMoves) {
  4478.     while (currentMove < target) {
  4479.         strcpy(buf, moveList[currentMove++]);
  4480.         SendToProgram(buf, toFirstProgFP);
  4481.     }
  4482.     } else {
  4483.     currentMove = target;
  4484.     }
  4485.     
  4486.     if (!appData.icsActive && gameMode == ForceMoves) {
  4487.     whiteTimeRemaining = timeRemaining[0][currentMove];
  4488.     blackTimeRemaining = timeRemaining[1][currentMove];
  4489.     }
  4490.     DisplayClocks(ReDisplayTimers);
  4491.     DisplayMove(currentMove - 1);
  4492.     DrawPosition(boardWidget, NULL, NULL, NULL);
  4493. }
  4494.  
  4495.  
  4496. void ResetProc(w, event, prms, nprms)
  4497.      Widget w;
  4498.      XEvent *event;
  4499.      String *prms;
  4500.      Cardinal *nprms;
  4501. {
  4502.     Reset(True);
  4503. }
  4504.  
  4505. void Reset(redraw)
  4506.      int redraw;
  4507. {
  4508.     flipView = False;
  4509.     startedFromSetupPosition = blackPlaysFirst = False;
  4510.     matchMode = MatchFalse;
  4511.     firstMove = True;
  4512.     whiteFlag = blackFlag = False;
  4513.     maybeThinking = False;
  4514.     endMessage[0] = NULLCHAR;
  4515.     ics_white[0] = ics_black[0] = NULLCHAR;
  4516.     ics_user_moved = ics_getting_history = False;
  4517.     ics_mode = IcsIdle;
  4518.     ics_gamenum = -1;
  4519.     
  4520.     ShutdownChessPrograms(NULL);
  4521.     lastGameMode = gameMode = BeginningOfGame;
  4522.     ModeHighlight();
  4523.     InitPosition(redraw);
  4524.     DisplayClocks(ResetTimers);
  4525.     timeRemaining[0][0] = whiteTimeRemaining;
  4526.     timeRemaining[1][0] = blackTimeRemaining;
  4527.     InitChessProgram(appData.firstHost, appData.firstChessProgram,
  4528.              &firstProgramPID, &toFirstProgFP,
  4529.              &fromFirstProgFP, &firstProgramXID, &firstSendTime);
  4530.     DisplayTitle("");
  4531.     DisplayMessage("");
  4532.     if (commentUp) CommentPopDown();
  4533.     if (promotionUp) {
  4534.     XtPopdown(promotionShell);
  4535.     XtDestroyWidget(promotionShell);
  4536.     promotionUp = False;
  4537.     }
  4538. }
  4539.  
  4540. void LoadPositionProc(w, event, prms, nprms)
  4541.      Widget w;
  4542.      XEvent *event;
  4543.      String *prms;
  4544.      Cardinal *nprms;
  4545. {
  4546.     if (gameMode != BeginningOfGame) {
  4547.     DisplayMessage("Press Reset first");
  4548.     return;
  4549.     }
  4550.     FileNamePopUp("Position file name?", "", LoadPosition);
  4551. }
  4552.  
  4553. Boolean LoadPosition(name)
  4554.      char *name;
  4555. {
  4556.     char *p, line[MSG_SIZ], buf[MSG_SIZ];
  4557.     Board initial_position;
  4558.     FILE *fp;
  4559.     int i, j, positionNumber;
  4560.     
  4561.     if (gameMode != BeginningOfGame) {
  4562.     DisplayMessage("Press Reset first");
  4563.     return False;
  4564.     }
  4565.     
  4566.     /* Parse position number if given */
  4567.     strcpy(line, name);
  4568.     p = strrchr(line, ' ');
  4569.     if (p == NULL) {
  4570.     positionNumber = 0;
  4571.     } else {
  4572.     *p++ = NULLCHAR;
  4573.     positionNumber = atoi(p);
  4574.     }
  4575.  
  4576.     if ((fp = fopen(line, "r")) == NULL) {
  4577.     sprintf(buf, "Can't open %s", line);
  4578.     DisplayMessage(buf);
  4579.     return False;
  4580.     }
  4581.     
  4582.     p = strrchr(name, '/');
  4583.     if (p == NULL)
  4584.       p = name;
  4585.     else
  4586.       p++;
  4587.     DisplayTitle(p);
  4588.  
  4589.     lastGameMode = gameMode = ForceMoves;
  4590.     ModeHighlight();
  4591.     startedFromSetupPosition = True;
  4592.     
  4593.     if (firstProgramXID == 0)
  4594.       InitChessProgram(appData.firstHost, appData.firstChessProgram,
  4595.                &firstProgramPID, &toFirstProgFP,
  4596.                &fromFirstProgFP, &firstProgramXID, &firstSendTime);
  4597.     
  4598.     if (positionNumber == 0) {
  4599.     /* Backward compatibility---don't look for '#' */
  4600.     (void) fgets(line, MSG_SIZ, fp);
  4601.     } else {
  4602.     while (positionNumber > 0) {
  4603.         /* skip postions before number positionNumber */
  4604.         if (fgets(line, MSG_SIZ, fp) == NULL) {
  4605.         Reset(True);
  4606.         DisplayMessage("Position not found in file");
  4607.         return False;
  4608.         }
  4609.         if (line[0] == '#') positionNumber--;
  4610.     }
  4611.     }
  4612.  
  4613.     (void) fgets(line, MSG_SIZ, fp);
  4614.     (void) fgets(line, MSG_SIZ, fp);
  4615.     
  4616.     for (i = BOARD_SIZE - 1; i >= 0; i--) {
  4617.     (void) fgets(line, MSG_SIZ, fp);
  4618.     for (p = line, j = 0; j < BOARD_SIZE; p++) {
  4619.         if (*p == ' ')
  4620.           continue;
  4621.         initial_position[i][j++] = CharToPiece(*p);
  4622.     }
  4623.     }
  4624.     
  4625.     blackPlaysFirst = False;
  4626.     if (!feof(fp)) {
  4627.     (void) fgets(line, MSG_SIZ, fp);
  4628.     if (strncmp(line, "black", strlen("black"))==0)
  4629.       blackPlaysFirst = True;
  4630.     }
  4631.     fclose(fp);
  4632.     
  4633.     if (blackPlaysFirst) {
  4634.     CopyBoard(boards[0], initial_position);
  4635.     strcpy(moveList[0], "");
  4636.     strcpy(parseList[0], "");
  4637.     currentMove = forwardMostMove = backwardMostMove = 1;
  4638.     CopyBoard(boards[1], initial_position);
  4639.     SendToProgram("force\na3\n", toFirstProgFP);
  4640.     SendCurrentBoard(toFirstProgFP);
  4641.     DisplayMessage("Black to play");
  4642.     } else {
  4643.     currentMove = forwardMostMove = backwardMostMove = 0;
  4644.     CopyBoard(boards[0], initial_position);
  4645.     SendCurrentBoard(toFirstProgFP);
  4646.     SendToProgram("force\n", toFirstProgFP);
  4647.     DisplayMessage("White to play");
  4648.     }
  4649.     
  4650.     DisplayClocks(ResetTimers);
  4651.     timeRemaining[0][1] = whiteTimeRemaining;
  4652.     timeRemaining[1][1] = blackTimeRemaining;
  4653.  
  4654.     DrawPosition(boardWidget, NULL, NULL, NULL);
  4655.     
  4656.     return (int) True;
  4657. }
  4658.  
  4659. void EditPositionProc(w, event, prms, nprms)
  4660.      Widget w;
  4661.      XEvent *event;
  4662.      String *prms;
  4663.      Cardinal *nprms;
  4664. {
  4665.     if (gameMode == EditPosition) {
  4666.     ForceProc(w, event, prms, nprms);
  4667.     return;
  4668.     }
  4669.     
  4670.     ForceProc(w, event, prms, nprms);
  4671.     if (gameMode != ForceMoves) return;
  4672.     
  4673.     DisplayTitle("<-- Press to set side to play next");
  4674.     DisplayMessage("Mouse: 1=drag, 2=white, 3=black");
  4675.     
  4676.     lastGameMode = gameMode = EditPosition;
  4677.     ModeHighlight();
  4678.     if (currentMove > 0)
  4679.       CopyBoard(boards[0], boards[currentMove]);
  4680.     
  4681.     blackPlaysFirst = !WhiteOnMove(currentMove);
  4682.     DisplayClocks(ResetTimers);
  4683.     currentMove = forwardMostMove = backwardMostMove = 0;
  4684. }
  4685.  
  4686. void EditPositionDone()
  4687. {
  4688.     startedFromSetupPosition = True;
  4689.     SendToProgram(appData.initString, toFirstProgFP);
  4690.     SendSearchDepth(toFirstProgFP);
  4691.     if (blackPlaysFirst) {
  4692.     strcpy(moveList[0], "");
  4693.     strcpy(parseList[0], "");
  4694.     currentMove = forwardMostMove = backwardMostMove = 1;
  4695.     CopyBoard(boards[1], boards[0]);
  4696.     SendToProgram("force\na3\n", toFirstProgFP);
  4697.     SendCurrentBoard(toFirstProgFP);
  4698.     DisplayTitle("");
  4699.     DisplayMessage("Black to play");
  4700.     } else {
  4701.     currentMove = forwardMostMove = backwardMostMove = 0;
  4702.     SendCurrentBoard(toFirstProgFP);
  4703.     SendToProgram("force\n", toFirstProgFP);
  4704.     DisplayTitle("");
  4705.     DisplayMessage("White to play");
  4706.     }
  4707.     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
  4708.     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
  4709.     lastGameMode = gameMode = ForceMoves;
  4710. }
  4711.  
  4712. void MachineWhiteProc(w, event, prms, nprms)
  4713.      Widget w;
  4714.      XEvent *event;
  4715.      String *prms;
  4716.      Cardinal *nprms;
  4717. {
  4718.     if (gameMode == PauseGame) PauseProc(w, event, prms, nprms);
  4719.     if (gameMode == PlayFromGameFile) ForceProc(w, event, prms, nprms);
  4720.     if (gameMode == EditPosition) EditPositionDone();
  4721.     
  4722.     if ((gameMode == EndOfGame) || (gameMode == TwoMachinesPlay) ||
  4723.     (appData.noChessProgram) || (gameMode == MachinePlaysWhite))
  4724.       return;
  4725.     
  4726.     if (!WhiteOnMove(gameMode == ForceMoves ? currentMove : forwardMostMove)) {
  4727.     DisplayMessage("It is not White's turn");
  4728.     return;
  4729.     }
  4730.     
  4731.     if (gameMode == ForceMoves) forwardMostMove = currentMove;
  4732.     
  4733.     lastGameMode = gameMode = MachinePlaysWhite;
  4734.     ModeHighlight();
  4735.     SendToProgram(appData.whiteString, toFirstProgFP);
  4736.     DisplayClocks(StartTimers);
  4737. }
  4738.  
  4739. void BackwardProc(w, event, prms, nprms)
  4740.      Widget w;
  4741.      XEvent *event;
  4742.      String *prms;
  4743.      Cardinal *nprms;
  4744. {
  4745.     int target;
  4746.     unsigned int state;
  4747.     
  4748.     if ((currentMove <= backwardMostMove) || (gameMode == EditPosition))
  4749.       return;
  4750.     
  4751.     if (gameMode == EndOfGame)
  4752.       ResurrectChessProgram();
  4753.     
  4754.     if (gameMode == PlayFromGameFile)
  4755.       PauseProc(w, event, prms, nprms);
  4756.     
  4757.     if (event == NULL) {
  4758.     /* Kludge */
  4759.     Window root, child;
  4760.     int root_x, root_y;
  4761.     int win_x, win_y;
  4762.     XQueryPointer(xDisplay, xBoardWindow,
  4763.               &root, &child, &root_x, &root_y,
  4764.               &win_x, &win_y, &state);
  4765.     } else {
  4766.     state = event->xkey.state;
  4767.     }
  4768.     if (state & ShiftMask)
  4769.       target = backwardMostMove;
  4770.     else
  4771.       target = currentMove - 1;
  4772.     
  4773.     if (gameMode == ForceMoves) {
  4774.     Attention(firstProgramPID);
  4775.     while (currentMove > target) {
  4776.         SendToProgram("undo\n", toFirstProgFP);
  4777.         currentMove--;
  4778.     }
  4779.     } else {
  4780.     currentMove = target;
  4781.     }
  4782.     
  4783.     if (!appData.icsActive && gameMode == ForceMoves) {
  4784.     whiteTimeRemaining = timeRemaining[0][currentMove];
  4785.     blackTimeRemaining = timeRemaining[1][currentMove];
  4786.     }
  4787.     DisplayClocks(ReDisplayTimers);
  4788.     DisplayMove(currentMove - 1);
  4789.     DrawPosition(boardWidget, NULL, NULL, NULL);
  4790. }
  4791.  
  4792. void FlipViewProc(w, event, prms, nprms)
  4793.      Widget w;
  4794.      XEvent *event;
  4795.      String *prms;
  4796.      Cardinal *nprms;
  4797. {
  4798.     flipView = !flipView;
  4799.     DrawPosition(boardWidget, NULL, NULL, NULL);
  4800. }
  4801.  
  4802. void SaveGameProc(w, event, prms, nprms)
  4803.      Widget w;
  4804.      XEvent *event;
  4805.      String *prms;
  4806.      Cardinal *nprms;
  4807. {
  4808.     char def[MSG_SIZ];
  4809.     
  4810.     if (appData.icsActive && ics_white[0] != NULLCHAR) {
  4811.     sprintf(def, "%s-%s.game", ics_white, ics_black);
  4812.     } else {
  4813.     def[0] = NULLCHAR;
  4814.     }
  4815.     FileNamePopUp("Filename for saved game?", def, SaveGame);
  4816. }
  4817.  
  4818. Boolean SaveGame(name)
  4819.      char *name;
  4820. {
  4821.     char buf[MSG_SIZ];
  4822.     int i;
  4823.     time_t tm;
  4824.     
  4825.     if ((gameFileFP = fopen(name, "a")) == NULL) {
  4826.     sprintf(buf, "Can't open %s", name);
  4827.     DisplayMessage(buf);
  4828.     return False;
  4829.     }
  4830.     
  4831.     tm = time((time_t *) NULL);
  4832.     
  4833.     fprintf(gameFileFP, "# %s game file -- %s", programName, ctime(&tm));
  4834.     PrintOpponents(gameFileFP);
  4835.     fprintf(gameFileFP, "\talgebraic\n");
  4836.     
  4837.     if (backwardMostMove > 0 || startedFromSetupPosition) {
  4838.     fprintf(gameFileFP, "[--------------\n");
  4839.     PrintPosition(gameFileFP, backwardMostMove);
  4840.     fprintf(gameFileFP, "--------------]\n");
  4841.     }
  4842.     i = backwardMostMove;
  4843.     if ((i % 2) == 1 && i < forwardMostMove) {
  4844.     fprintf(gameFileFP, "%d. ...  %s\n", i/2 + 1, parseList[i]);
  4845.     i++;
  4846.     }
  4847.     while (i < forwardMostMove) {
  4848.     fprintf(gameFileFP, "%d. %s  ", i/2 + 1, parseList[i]);
  4849.     i++;
  4850.     if (i >= forwardMostMove) {
  4851.         fprintf(gameFileFP, "\n");
  4852.         break;
  4853.     }
  4854.     fprintf(gameFileFP, "%s\n", parseList[i]);
  4855.     i++;
  4856.     }
  4857.     
  4858.     if (endMessage[0] != NULLCHAR)
  4859.       fprintf(gameFileFP, "%s\n", endMessage);
  4860.     
  4861.     fclose(gameFileFP);
  4862.     gameFileFP = NULL;
  4863.     yynewfile();
  4864.     return True;
  4865. }
  4866.  
  4867. #ifdef notdef  
  4868. /* currently unused */
  4869. void SwitchProc(w, event, prms, nprms)
  4870.      Widget w;
  4871.      XEvent *event;
  4872.      String *prms;
  4873.      Cardinal *nprms;
  4874. {
  4875.     if (appData.noChessProgram) return;
  4876.     if (gameMode == PauseGame) PauseProc(w, event);
  4877.     switch (gameMode) {
  4878.       default:
  4879.     return;
  4880.       case MachinePlaysWhite:
  4881.     if (WhiteOnMove(forwardMostMove)) {
  4882.         DisplayMessage("Wait until your turn");
  4883.         return;
  4884.     }
  4885.     lastGameMode = gameMode = MachinePlaysBlack;
  4886.     ModeHighlight();
  4887.     break;
  4888.       case BeginningOfGame:
  4889.       case MachinePlaysBlack:
  4890.     if (!WhiteOnMove(forwardMostMove)) {
  4891.         DisplayMessage("Wait until your turn");
  4892.         return;
  4893.     }
  4894.     if (forwardMostMove == 0) {
  4895.         MachineWhiteProc(w, event);
  4896.         return;
  4897.     }
  4898.     lastGameMode = gameMode = MachinePlaysWhite;
  4899.     ModeHighlight();
  4900.     break;
  4901.     }
  4902.     
  4903.     Attention(firstProgramPID);
  4904.     SendToProgram("switch\n", toFirstProgFP);
  4905. }
  4906. #endif /*notdef*/
  4907.  
  4908. void ForceProc(w, event, prms, nprms)
  4909.      Widget w;
  4910.      XEvent *event;
  4911.      String *prms;
  4912.      Cardinal *nprms;
  4913. {
  4914.     int i;
  4915.     
  4916.     if (gameMode == PauseGame) PauseProc(w, event, prms, nprms);
  4917.     switch (gameMode) {
  4918.       case MachinePlaysWhite:
  4919.     if (WhiteOnMove(forwardMostMove)) {
  4920.         DisplayMessage("Wait until your turn");
  4921.         return;
  4922.     }
  4923.     Attention(firstProgramPID);
  4924.     SendToProgram("force\n", toFirstProgFP);
  4925.     break;
  4926.       case MachinePlaysBlack:
  4927.     if (!WhiteOnMove(forwardMostMove)) {
  4928.         DisplayMessage("Wait until your turn");
  4929.         return;
  4930.     }
  4931.     Attention(firstProgramPID);
  4932.     SendToProgram("force\n", toFirstProgFP);
  4933.     break;
  4934.       case BeginningOfGame:
  4935.     SendToProgram("force\n", toFirstProgFP);
  4936.     break;
  4937.       case PlayFromGameFile:
  4938.     if (readGameXID != 0) {
  4939.         XtRemoveTimeOut(readGameXID);
  4940.         readGameXID = 0;
  4941.     }
  4942.     if (gameFileFP != NULL) {
  4943.         fclose(gameFileFP);
  4944.         gameFileFP = NULL;
  4945.         yynewfile();
  4946.     }
  4947.     break;
  4948.       case EndOfGame:
  4949.     ResurrectChessProgram();
  4950.     return;
  4951.       case EditPosition:
  4952.     EditPositionDone();
  4953.     break;
  4954.       case TwoMachinesPlay:
  4955.     ShutdownChessPrograms("");
  4956.     ResurrectChessProgram();
  4957.     return;
  4958.       default:
  4959.     return;
  4960.     }
  4961.     
  4962.     if (gameMode == MachinePlaysWhite ||
  4963.     gameMode == MachinePlaysBlack ||
  4964.     gameMode == TwoMachinesPlay ||
  4965.     gameMode == PlayFromGameFile) {
  4966.     i = forwardMostMove;
  4967.     while (i > currentMove) {
  4968.         SendToProgram("undo\n", toFirstProgFP);
  4969.         i--;
  4970.     }
  4971.     whiteTimeRemaining = timeRemaining[0][currentMove];
  4972.     blackTimeRemaining = timeRemaining[1][currentMove];
  4973.     if (whiteFlag || blackFlag) {
  4974.         whiteFlag = blackFlag = 0;
  4975.     }
  4976.     DisplayTitle("");
  4977.     }        
  4978.     
  4979.     lastGameMode = gameMode = ForceMoves;
  4980.     ModeHighlight();
  4981.     
  4982.     DisplayClocks(StopTimers);
  4983. }
  4984.  
  4985. void NothingProc(w, event, prms, nprms)
  4986.      Widget w;
  4987.      XEvent *event;
  4988.      String *prms;
  4989.      Cardinal *nprms;
  4990. {
  4991.     return;
  4992. }
  4993.  
  4994. void HintProc(w, event, prms, nprms)
  4995.      Widget w;
  4996.      XEvent *event;
  4997.      String *prms;
  4998.      Cardinal *nprms;
  4999. {
  5000.     if (appData.noChessProgram) return;
  5001.     switch (gameMode) {
  5002.       case MachinePlaysWhite:
  5003.     if (WhiteOnMove(forwardMostMove)) {
  5004.         DisplayMessage("Wait until your turn");
  5005.         return;
  5006.     }
  5007.     break;
  5008.       case BeginningOfGame:
  5009.       case MachinePlaysBlack:
  5010.     if (!WhiteOnMove(forwardMostMove)) {
  5011.         DisplayMessage("Wait until your turn");
  5012.         return;
  5013.     }
  5014.     break;
  5015.       default:
  5016.     DisplayMessage("No hint available");
  5017.     return;
  5018.     }
  5019.     Attention(firstProgramPID);
  5020.     SendToProgram("hint\n", toFirstProgFP);
  5021. }
  5022.  
  5023. void PrintPosition(fp, move)
  5024.      FILE *fp;
  5025.      int move;
  5026. {
  5027.     int i, j;
  5028.     
  5029.     for (i = BOARD_SIZE - 1; i >= 0; i--) {
  5030.     for (j = 0; j < BOARD_SIZE; j++) {
  5031.         fprintf(fp, "%c", PieceToChar(boards[move][i][j]));
  5032.         fputc(j == BOARD_SIZE - 1 ? '\n' : ' ', fp);
  5033.     }
  5034.     }
  5035.     if ((gameMode == EditPosition) ? !blackPlaysFirst : (move % 2 == 0))
  5036.       fprintf(fp, "white to play\n");
  5037.     else
  5038.       fprintf(fp, "black to play\n");
  5039. }
  5040.  
  5041. void PrintOpponents(fp)
  5042.      FILE *fp;
  5043. {
  5044.     char host_name[MSG_SIZ];
  5045.     
  5046. #if defined(SVR4) && defined(sun)
  5047.     sysinfo(SI_HOSTNAME, host_name, MSG_SIZ);
  5048. #else
  5049.     gethostname(host_name, MSG_SIZ);
  5050. #endif
  5051.     switch (lastGameMode) {
  5052.       case MachinePlaysWhite:
  5053.     fprintf(fp, "\t%s@%s vs. %s@%s\n", appData.firstChessProgram,
  5054.         appData.firstHost, getpwuid(getuid())->pw_name,
  5055.         host_name);
  5056.     break;
  5057.       case MachinePlaysBlack:
  5058.     fprintf(fp, "\t%s@%s vs. %s@%s\n", getpwuid(getuid())->pw_name,
  5059.         host_name, appData.firstChessProgram,
  5060.         appData.firstHost);
  5061.     break;
  5062.       case TwoMachinesPlay:
  5063.     fprintf(fp, "\t%s@%s vs. %s@%s\n", appData.secondChessProgram,
  5064.         appData.secondHost, appData.firstChessProgram,
  5065.         appData.firstHost);
  5066.     break;
  5067.       default:
  5068.     if (appData.icsActive && ics_white[0] != NULLCHAR) {
  5069.         fprintf(fp, "\t%s vs. %s\n",
  5070.             ics_white, ics_black);
  5071.     } else {
  5072.         fprintf(fp, "\n");
  5073.     }
  5074.     break;
  5075.     }
  5076. }
  5077.  
  5078. void SavePositionProc(w, event, prms, nprms)
  5079.      Widget w;
  5080.      XEvent *event;
  5081.      String *prms;
  5082.      Cardinal *nprms;
  5083. {
  5084.     char def[MSG_SIZ];
  5085.     
  5086.     if (appData.icsActive && ics_white[0] != NULLCHAR) {
  5087.     sprintf(def, "%s-%s.pos", ics_white, ics_black);
  5088.     } else {
  5089.     def[0] = NULLCHAR;
  5090.     }
  5091.     FileNamePopUp("Filename for saved position?", def, SavePosition);
  5092. }
  5093.  
  5094. Boolean SavePosition(name)
  5095.      char *name;
  5096. {
  5097.     char buf[MSG_SIZ];
  5098.     FILE *fp;
  5099.     time_t tm;
  5100.     
  5101.     if ((fp = fopen(name, "a")) == NULL) {
  5102.     sprintf(buf, "Can't open %s", name);
  5103.     DisplayMessage(buf);
  5104.     return False;
  5105.     }
  5106.     
  5107.     tm = time((time_t *) NULL);
  5108.     
  5109.     fprintf(fp, "# %s position file -- %s", programName, ctime(&tm));
  5110.     PrintOpponents(fp);
  5111.     fprintf(fp, "\n");
  5112.     PrintPosition(fp, currentMove);
  5113.     fclose(fp);
  5114.     return True;
  5115. }
  5116.  
  5117. void TwoMachinesProc(w, event, prms, nprms)
  5118.      Widget w;
  5119.      XEvent *event;
  5120.      String *prms;
  5121.      Cardinal *nprms;
  5122. {
  5123.     int i;
  5124.     MatchMode matchKind;
  5125.     
  5126.     if (gameMode == PauseGame) PauseProc(w, event, prms, nprms);
  5127.     if (gameMode == PlayFromGameFile) ForceProc(w, event, prms, nprms);
  5128.     if ((gameMode == EndOfGame) || (gameMode == TwoMachinesPlay)
  5129.     || appData.noChessProgram)
  5130.       return;
  5131.     
  5132.     if (matchMode == MatchFalse) {
  5133.     switch (gameMode) {
  5134.       case PauseGame:
  5135.       case PlayFromGameFile:
  5136.         return;
  5137.       case MachinePlaysWhite:
  5138.       case MachinePlaysBlack:
  5139.         ForceProc(w, event, prms, nprms);
  5140.         if (gameMode != ForceMoves) return;
  5141.         matchKind = MatchOpening;
  5142.         break;
  5143.       case ForceMoves:
  5144.         matchKind = MatchOpening;
  5145.         break;
  5146.       case EditPosition:
  5147.         EditPositionDone();
  5148.         matchKind = MatchPosition;
  5149.         break;
  5150.       case BeginningOfGame:
  5151.       default:
  5152.         matchKind = MatchInit;
  5153.         break;
  5154.     }
  5155.     } else {
  5156.     matchKind = matchMode;
  5157.     }
  5158.     
  5159.     forwardMostMove = currentMove;
  5160.     
  5161.     flipView = False;
  5162.     firstMove = False;
  5163.     
  5164.     switch (matchKind) {
  5165.       case MatchOpening:
  5166.     if (firstProgramXID == 0) {
  5167.         if (*appData.loadGameFile == NULLCHAR) {
  5168.         DisplayMessage("You need to specify a game file");
  5169.         return;
  5170.         }
  5171.         InitChessProgram(appData.firstHost,
  5172.                  appData.firstChessProgram,
  5173.                  &firstProgramPID, &toFirstProgFP,
  5174.                  &fromFirstProgFP, &firstProgramXID,
  5175.                  &firstSendTime);
  5176.         if (!LoadGame(appData.loadGameFile)) {
  5177.         ShutdownChessPrograms("Bad game file");
  5178.         return;
  5179.         }
  5180.         DrawPosition(boardWidget, NULL, NULL, NULL);
  5181.     }
  5182.     InitChessProgram(appData.secondHost,
  5183.              appData.secondChessProgram,
  5184.              &secondProgramPID, &toSecondProgFP,
  5185.              &fromSecondProgFP, &secondProgramXID,
  5186.              &secondSendTime);
  5187.     if (startedFromSetupPosition) {
  5188.         if (blackPlaysFirst) {
  5189.         SendToProgram("force\na3\n", toSecondProgFP);
  5190.         SendBoard(toSecondProgFP,
  5191.               boards[backwardMostMove]);
  5192.         } else {
  5193.         SendBoard(toSecondProgFP,
  5194.               boards[backwardMostMove]);
  5195.         SendToProgram("force\n", toSecondProgFP);
  5196.         }
  5197.     } else {
  5198.         SendToProgram("force\n", toSecondProgFP);
  5199.     }
  5200.     for (i = backwardMostMove; i < forwardMostMove; i++)
  5201.       SendToProgram(moveList[i], toSecondProgFP);
  5202.     lastGameMode = gameMode = TwoMachinesPlay;
  5203.     ModeHighlight();
  5204.     firstMove = True;
  5205.     if (WhiteOnMove(forwardMostMove))
  5206.       SendToProgram(appData.whiteString, toSecondProgFP);
  5207.     else
  5208.       SendToProgram(appData.blackString, toFirstProgFP);
  5209.     break;
  5210.     
  5211.       case MatchPosition:
  5212.     if (firstProgramXID == 0) {
  5213.         if (*appData.loadPositionFile == NULLCHAR) {
  5214.         DisplayMessage("You need to specify a position file");
  5215.         return;
  5216.         }
  5217.         InitChessProgram(appData.firstHost,
  5218.                  appData.firstChessProgram,
  5219.                  &firstProgramPID, &toFirstProgFP,
  5220.                  &fromFirstProgFP, &firstProgramXID,
  5221.                  &firstSendTime);
  5222.         if (!LoadPosition(appData.loadPositionFile))
  5223.           return;
  5224.     }
  5225.     InitChessProgram(appData.secondHost,
  5226.              appData.secondChessProgram,
  5227.              &secondProgramPID, &toSecondProgFP,
  5228.              &fromSecondProgFP, &secondProgramXID,
  5229.              &secondSendTime);
  5230.     if (blackPlaysFirst)
  5231.       SendToProgram("force\na3\n", toSecondProgFP);
  5232.     SendCurrentBoard(toSecondProgFP);
  5233.     lastGameMode = gameMode = TwoMachinesPlay;
  5234.     ModeHighlight();
  5235.     firstMove = True;
  5236.     if (WhiteOnMove(forwardMostMove))
  5237.       SendToProgram(appData.whiteString, toSecondProgFP);
  5238.     else
  5239.       SendToProgram(appData.blackString, toFirstProgFP);
  5240.     break;
  5241.     
  5242.       case MatchInit:
  5243.     InitPosition(True);
  5244.     if (firstProgramXID == 0)
  5245.       InitChessProgram(appData.firstHost,
  5246.                appData.firstChessProgram,
  5247.                &firstProgramPID, &toFirstProgFP,
  5248.                &fromFirstProgFP, &firstProgramXID,
  5249.                &firstSendTime);
  5250.     InitChessProgram(appData.secondHost,
  5251.              appData.secondChessProgram,
  5252.              &secondProgramPID, &toSecondProgFP,
  5253.              &fromSecondProgFP, &secondProgramXID,
  5254.              &secondSendTime);
  5255.     lastGameMode = gameMode = TwoMachinesPlay;
  5256.     ModeHighlight();
  5257.     SendToProgram(appData.whiteString, toSecondProgFP);
  5258.     
  5259.       default:
  5260.     break;
  5261.     }
  5262.     
  5263.     if (!firstSendTime || !secondSendTime) {
  5264.     DisplayClocks(ResetTimers);
  5265.     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
  5266.     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
  5267.     }
  5268.     DisplayClocks(StartTimers);
  5269. }
  5270.  
  5271. void PauseProc(w, event, prms, nprms)
  5272.      Widget w;
  5273.      XEvent *event;
  5274.      String *prms;
  5275.      Cardinal *nprms;
  5276. {
  5277.     switch (gameMode) {
  5278.       case EndOfGame:
  5279.       case EditPosition:
  5280.       default:
  5281.     return;
  5282.       case ForceMoves:
  5283.     if (appData.icsActive) {
  5284.         pausePreviousMode = gameMode;
  5285.         gameMode = PauseGame;
  5286.         ModeHighlight();
  5287.     }
  5288.     return;
  5289.       case PauseGame:
  5290.     gameMode = pausePreviousMode;
  5291.     ModeHighlight();
  5292.     pausePreviousMode = PauseGame;
  5293.     if (gameMode == MachinePlaysWhite ||
  5294.         gameMode == MachinePlaysBlack) {
  5295.         DisplayClocks(StartTimers);
  5296.     } else {
  5297.         DisplayClocks(ReDisplayTimers);
  5298.     }
  5299.     if (gameMode == PlayFromGameFile &&
  5300.         readGameXID == 0 &&
  5301.         appData.timeDelay >= 0) {
  5302.         readGameXID =
  5303.           XtAppAddTimeOut(appContext,
  5304.                   (int) (1000 * appData.timeDelay),
  5305.                   (XtTimerCallbackProc) LoadGameLoop, NULL);
  5306.     }
  5307.     break;
  5308.       case PlayFromGameFile:
  5309.     if (readGameXID != 0) {
  5310.         XtRemoveTimeOut(readGameXID);
  5311.         readGameXID = 0;
  5312.     }
  5313.     pausePreviousMode = gameMode;
  5314.     gameMode = PauseGame;
  5315.     ModeHighlight();
  5316.     break;
  5317.       case BeginningOfGame:
  5318.       case MachinePlaysWhite:
  5319.       case MachinePlaysBlack:
  5320.       case TwoMachinesPlay:
  5321.     if (forwardMostMove == 0)
  5322.       return;    /* don't pause if no one has moved */
  5323.     if ((gameMode == MachinePlaysWhite &&
  5324.          !WhiteOnMove(forwardMostMove)) ||
  5325.         (gameMode == MachinePlaysBlack &&
  5326.          WhiteOnMove(forwardMostMove))) {
  5327.         DisplayClocks(StopTimers);
  5328.     }
  5329.     pausePreviousMode = gameMode;
  5330.     gameMode = PauseGame;
  5331.     ModeHighlight();
  5332.     break;
  5333.     }
  5334. }
  5335.  
  5336. void LoadGameProc(w, event, prms, nprms)
  5337.      Widget w;
  5338.      XEvent *event;
  5339.      String *prms;
  5340.      Cardinal *nprms;
  5341. {
  5342.     if (gameMode == PlayFromGameFile) {
  5343.     ForceProc(w, event, prms, nprms);
  5344.     return;
  5345.     }
  5346.     if (gameMode != BeginningOfGame) {
  5347.     DisplayMessage("Press Reset first");
  5348.     return;
  5349.     }
  5350.     FileNamePopUp("Game file name?", "", LoadGame);
  5351. }
  5352.  
  5353. void Iconify(w, event, prms, nprms)
  5354.      Widget w;
  5355.      XEvent *event;
  5356.      String *prms;
  5357.      Cardinal *nprms;
  5358. {
  5359.     Arg args[1];
  5360.     
  5361.     fromX = fromY = -1;
  5362.     
  5363.     XtSetArg(args[0], XtNiconic, True);
  5364.     XtSetValues(shellWidget, args, 1);
  5365. }
  5366.  
  5367. void SendToProgram(message, fp)
  5368.      char *message;
  5369.      FILE *fp;
  5370. {
  5371.     if (fp == NULL) return;
  5372.     lastMsgFP = fp;
  5373.     
  5374.     if (appData.debugMode)
  5375.       fprintf(stderr, "Sending to %s: %s\n",
  5376.           fp == toFirstProgFP ? "first" : "second", message);
  5377.     
  5378.     if (message[strlen(message) - 1] != '\n')
  5379.       fprintf(fp, "\n%s\n", message);
  5380.     else
  5381.       fputs(message, fp);
  5382.     fflush(fp);
  5383. }
  5384.  
  5385. void ReceiveFromProgram(fp, source, id)
  5386.      FILE *fp;
  5387.      int *source;
  5388.      XtInputId *id;
  5389. {
  5390.     char message[MSG_SIZ], *end_str, *name, *number;
  5391.     extern char *sys_errlist[];
  5392.  
  5393.     if (fgets(message, MSG_SIZ, fp) == NULL) {
  5394.     if (fp == fromFirstProgFP) {
  5395.         number = "first";
  5396.         name = appData.firstChessProgram;
  5397.     } else if (fp == fromSecondProgFP) {
  5398.         number = "second";
  5399.         name = appData.secondChessProgram;
  5400.     } else {
  5401.         return;
  5402.     }
  5403.     if (ferror(fp) == 0) {
  5404.         sprintf(message, "%s chess program (%s) exited unexpectedly",
  5405.             number, name);
  5406.         fprintf(stderr, "%s: %s\n", programName, message);
  5407.     } else {
  5408.         sprintf(message,
  5409.             "error reading from %s chess program (%s): %s",
  5410.             number, name, sys_errlist[ferror(fp)]);
  5411.         fprintf(stderr, "%s: %s\n", programName, message);
  5412.     }
  5413.     ShutdownChessPrograms(message);
  5414.     return;
  5415.     }
  5416.     
  5417.     if ((end_str = strchr(message, '\r')) != NULL)
  5418.       *end_str = NULLCHAR;
  5419.     if ((end_str = strchr(message, '\n')) != NULL)
  5420.       *end_str = NULLCHAR;
  5421.     
  5422.     if (appData.debugMode)
  5423.       fprintf(stderr, "Received from %s: %s\n",
  5424.           fp == fromFirstProgFP ? "first" : "second", message);
  5425.     HandleMachineMove(message, fp);
  5426. }
  5427.  
  5428. void SendSearchDepth(fp)
  5429.      FILE *fp;
  5430. {
  5431.     char message[MSG_SIZ];
  5432.     
  5433.     if (appData.searchDepth <= 0) return;
  5434.     
  5435.     sprintf(message, "depth\n%d\nhelp\n", appData.searchDepth);
  5436.     /* note kludge: "help" command forces gnuchessx to print
  5437.        out something that ends with a newline. */
  5438.     SendToProgram(message, fp);
  5439. }
  5440.  
  5441. void SendTimeRemaining(fp)
  5442.      FILE *fp;
  5443. {
  5444.     char message[MSG_SIZ];
  5445.     long time;
  5446.  
  5447.     if (WhiteOnMove(forwardMostMove))
  5448.       time = whiteTimeRemaining;
  5449.     else
  5450.       time = blackTimeRemaining;
  5451.     
  5452.     if (time <= 0) time = 1000;
  5453.     
  5454.     sprintf(message, "time %d\n", time/10);
  5455.     SendToProgram(message, fp);
  5456. }
  5457.  
  5458.  
  5459. void DisplayMove(moveNumber)
  5460.      int moveNumber;
  5461. {
  5462.     char message[MSG_SIZ];
  5463.     
  5464.     if (moveNumber < 0) {
  5465.     if (moveNumber == forwardMostMove - 1)
  5466.       DisplayMessage(endMessage);
  5467.     else
  5468.       DisplayMessage("");
  5469.     } else {
  5470.     sprintf(message, "%d. %s%s  %s", moveNumber / 2 + 1,
  5471.         WhiteOnMove(moveNumber) ? "" : "... ",
  5472.         parseList[moveNumber],
  5473.         moveNumber == forwardMostMove - 1 ? endMessage : "");
  5474.     DisplayMessage(message);
  5475.     }
  5476. }
  5477.  
  5478. void DisplayMessage(message)
  5479.      char *message;
  5480. {
  5481.     Arg arg;
  5482.     
  5483.     XtSetArg(arg, XtNlabel, message);
  5484.     XtSetValues(messageWidget, &arg, 1);
  5485. }
  5486.  
  5487. void DisplayTitle(title)
  5488.      char *title;
  5489. {
  5490.     Arg arg;
  5491.     
  5492.     XtSetArg(arg, XtNlabel, title);
  5493.     XtSetValues(titleWidget, &arg, 1);
  5494. }
  5495.  
  5496. /*
  5497.  * This routine sends a SIGINT (^C interrupt) to gnuchess to awaken it
  5498.  * if it might be busy thinking on our time.  This normally isn't needed,
  5499.  * but is useful on systems where the FIONREAD ioctl doesn't work (such 
  5500.  * as ESIX), since on those systems the gnuchess feature that lets you 
  5501.  * interrupt its thinking just by typing a command does not work.
  5502.  *
  5503.  * In the future, similar code could be used to stop gnuchess and make
  5504.  * it move immediately when it is thinking about its own move; this could
  5505.  * be useful if we want to make Backward or ForceMoves work while gnuchess
  5506.  * is thinking. --t.mann
  5507.  */
  5508. void Attention(pid)
  5509.      int pid;
  5510. {
  5511. #if defined(ATTENTION) || defined(ESIX) || !defined(FIONREAD)
  5512.     if (appData.noChessProgram || (pid == 0)) return;
  5513.     switch (gameMode) {
  5514.       case MachinePlaysWhite:
  5515.       case MachinePlaysBlack:
  5516.       case TwoMachinesPlay:
  5517.     if (forwardMostMove > backwardMostMove + 1 && maybeThinking) {
  5518.         if (appData.debugMode)
  5519.           fprintf(stderr, "Sending SIGINT to %s\n",
  5520.               pid == firstProgramPID ? "first" : "second");
  5521.         (void) kill(pid, SIGINT); /* stop it thinking */
  5522.     }
  5523.     break;
  5524.     }
  5525. #endif /*ATTENTION*/
  5526. }
  5527.  
  5528. void CheckFlags()
  5529. {
  5530.     if (whiteTimeRemaining <= 0) {
  5531.     if (!whiteFlag) {
  5532.         whiteFlag = True;
  5533.         if (appData.icsActive) {
  5534.         if (appData.autoCallFlag &&
  5535.             ics_mode == IcsPlayingBlack && !blackFlag)
  5536.           SendToICS("flag\n");
  5537.         } else {
  5538.         if (blackFlag)
  5539.           DisplayTitle("Both flags have fallen");
  5540.         else
  5541.           DisplayTitle("White's flag has fallen");
  5542.         }
  5543.     }
  5544.     }
  5545.     if (blackTimeRemaining <= 0) {
  5546.     if (!blackFlag) {
  5547.         blackFlag = True;
  5548.         if (appData.icsActive) {
  5549.         if (appData.autoCallFlag &&
  5550.             ics_mode == IcsPlayingWhite && !whiteFlag)
  5551.           SendToICS("flag\n");
  5552.         } else {
  5553.         if (whiteFlag)
  5554.           DisplayTitle("Both flags have fallen");
  5555.         else
  5556.           DisplayTitle("Black's flag has fallen");
  5557.         }
  5558.     }
  5559.     }
  5560. }
  5561.  
  5562. void CheckTimeControl()
  5563. {
  5564.     if (!appData.clockMode) return;
  5565.     if (appData.icsActive) return;
  5566.     if (forwardMostMove == 0) return;
  5567.     /*
  5568.      * add time to clocks when time control is achieved
  5569.      */
  5570.     if ((forwardMostMove % (appData.movesPerSession * 2)) == 0) {
  5571.     whiteTimeRemaining += timeControl;
  5572.     blackTimeRemaining += timeControl;
  5573.     }
  5574. }
  5575.  
  5576. void DisplayLabels()
  5577. {
  5578.     DisplayTimerLabel(whiteTimerWidget, "White", whiteTimeRemaining);
  5579.     DisplayTimerLabel(blackTimerWidget, "Black", blackTimeRemaining);
  5580. }
  5581.  
  5582. #ifdef HAS_GETTIMEOFDAY
  5583. static struct timeval tickStartTV;
  5584. static int tickLength;
  5585.  
  5586. int PartialTickLength()
  5587. {
  5588.     struct timeval tv;
  5589.     struct timezone tz;
  5590.     int ptl;
  5591.     
  5592.     gettimeofday(&tv, &tz);
  5593.     ptl = ( (tv.tv_sec - tickStartTV.tv_sec)*1000000 +
  5594.        (tv.tv_usec - tickStartTV.tv_usec) + 500 ) / 1000;
  5595.     if (ptl > tickLength) ptl = tickLength;
  5596.     return ptl;
  5597. }
  5598. #else /*!HAS_GETTIMEOFDAY*/
  5599. #define tickLength 1000
  5600. #endif /*HAS_GETTIMEOFDAY*/
  5601.  
  5602. /*
  5603.  * DisplayClocks manages the game clocks.
  5604.  *
  5605.  * In tournament play, black starts the clock and then white makes a move.
  5606.  * We give the human user a slight advantage if he is playing white---the
  5607.  * clocks don't run until he makes his first move, so it takes zero time.
  5608.  * Also, DisplayClocks doesn't account for network lag so it could get
  5609.  * out of sync with GNU Chess's clock -- but then, referees are always right.
  5610.  */
  5611. void DisplayClocks(clock_mode)
  5612.      int clock_mode;
  5613. {
  5614. #ifdef HAS_GETTIMEOFDAY
  5615.     struct timezone tz;
  5616. #endif /*HAS_GETTIMEOFDAY*/
  5617.     long timeRemaining;
  5618.     
  5619.     switch (clock_mode) {
  5620.       case ResetTimers:
  5621.     /* Stop clocks and reset to a fresh time control */
  5622.     if (timerXID != 0) {
  5623.         XtRemoveTimeOut(timerXID);
  5624.         timerXID = 0;
  5625.     }
  5626.     whiteTimeRemaining = timeControl;
  5627.     blackTimeRemaining = timeControl;
  5628.     if (whiteFlag || blackFlag) {
  5629.         DisplayTitle("");
  5630.         whiteFlag = blackFlag = False;
  5631.     }
  5632.     DisplayLabels();
  5633.     break;
  5634.     
  5635.       case DecrementTimers:
  5636.     /* Decrement running clock to next 1-second boundary */
  5637.     timerXID = 0;
  5638.     if (!appData.clockMode) return;
  5639.     
  5640.     if (WhiteOnMove(forwardMostMove)) {
  5641.         timeRemaining = whiteTimeRemaining -= tickLength;
  5642.         DisplayTimerLabel(whiteTimerWidget, "White", whiteTimeRemaining);
  5643.     } else {
  5644.         timeRemaining = blackTimeRemaining -= tickLength;
  5645.         DisplayTimerLabel(blackTimerWidget, "Black", blackTimeRemaining);
  5646.     }
  5647.     
  5648.     CheckFlags();
  5649.     
  5650. #ifdef HAS_GETTIMEOFDAY
  5651.     tickLength = (timeRemaining <= 1000 && timeRemaining > 0) ? 100 : 1000;
  5652.     gettimeofday(&tickStartTV, &tz);
  5653. #endif /*HAS_GETTIMEOFDAY*/
  5654.     timerXID =
  5655.       XtAppAddTimeOut(appContext, tickLength,
  5656.               (XtTimerCallbackProc) DisplayClocks,
  5657.               (XtPointer) DecrementTimers);
  5658.     break;
  5659.     
  5660.       case SwitchTimers:
  5661.     /* A player has just moved, so stop the previously running
  5662.        clock and start the other one. */
  5663.     if (timerXID != 0) {
  5664.         XtRemoveTimeOut(timerXID);
  5665.         timerXID = 0;
  5666. #ifdef HAS_GETTIMEOFDAY
  5667.         if (appData.clockMode) {
  5668.         if (WhiteOnMove(forwardMostMove))
  5669.           blackTimeRemaining -= PartialTickLength();
  5670.         else
  5671.           whiteTimeRemaining -= PartialTickLength();
  5672.         CheckFlags();
  5673.         }
  5674. #endif /*HAS_GETTIMEOFDAY*/
  5675.     }
  5676.     CheckTimeControl();
  5677.     DisplayLabels();
  5678.     if (!appData.clockMode) return;
  5679.     if (gameMode == PauseGame &&
  5680.         (pausePreviousMode == MachinePlaysBlack ||
  5681.          pausePreviousMode == MachinePlaysWhite)) return;
  5682.     
  5683.     timeRemaining = WhiteOnMove(forwardMostMove) ?
  5684.       whiteTimeRemaining : blackTimeRemaining;
  5685.  
  5686. #ifdef HAS_GETTIMEOFDAY
  5687.     tickLength = (timeRemaining <= 1000 && timeRemaining > 0) ?
  5688.       ((timeRemaining-1) % 100) + 1 : ((timeRemaining-1) % 1000) + 1;
  5689.     if (tickLength <= 0) tickLength += 1000;
  5690.     gettimeofday(&tickStartTV, &tz);
  5691. #endif /*HAS_GETTIMEOFDAY*/
  5692.     timerXID =
  5693.       XtAppAddTimeOut(appContext, tickLength,
  5694.               (XtTimerCallbackProc) DisplayClocks,
  5695.               (XtPointer) DecrementTimers);
  5696.     break;
  5697.     
  5698.       case ReDisplayTimers:
  5699.     /* Display current clock values */
  5700.     DisplayLabels();
  5701.     break;
  5702.     
  5703.       case StopTimers:
  5704.     /* Stop both clocks */
  5705.     if (timerXID == 0) return;
  5706.     XtRemoveTimeOut(timerXID);
  5707.     timerXID = 0;
  5708.     if (!appData.clockMode) return;
  5709. #ifdef HAS_GETTIMEOFDAY
  5710.     if (WhiteOnMove(forwardMostMove))
  5711.       whiteTimeRemaining -= PartialTickLength();
  5712.     else
  5713.       blackTimeRemaining -= PartialTickLength();
  5714.     CheckFlags();
  5715.     DisplayLabels();
  5716. #endif /*HAS_GETTIMEOFDAY*/
  5717.     break;
  5718.     
  5719.       case StartTimers:
  5720.     /* Start clock of player on move, if not already running. */
  5721.     DisplayLabels();
  5722.     if (!appData.clockMode) return;
  5723.     if (timerXID != 0) return;
  5724.     
  5725.     timeRemaining = WhiteOnMove(forwardMostMove) ?
  5726.       whiteTimeRemaining : blackTimeRemaining;
  5727.  
  5728. #ifdef HAS_GETTIMEOFDAY
  5729.     tickLength = (timeRemaining <= 1000 && timeRemaining > 0) ?
  5730.       ((timeRemaining-1) % 100) + 1 : ((timeRemaining-1) % 1000) + 1;
  5731.     if (tickLength <= 0) tickLength += 1000;
  5732.     gettimeofday(&tickStartTV, &tz);
  5733. #endif /*HAS_GETTIMEOFDAY*/
  5734.     timerXID =
  5735.       XtAppAddTimeOut(appContext, tickLength,
  5736.               (XtTimerCallbackProc) DisplayClocks,
  5737.               (XtPointer)DecrementTimers);
  5738.     break;
  5739.     }
  5740. }
  5741.  
  5742. void DisplayTimerLabel(w, color, timer)
  5743.      Widget w;
  5744.      char *color;
  5745.      long timer;
  5746. {
  5747.     char buf[MSG_SIZ];
  5748.     Arg args[3];
  5749.     
  5750.     if (appData.clockMode) {
  5751.     sprintf(buf, "%s: %s", color, TimeString(timer));
  5752.     XtSetArg(args[0], XtNlabel, buf);
  5753.     } else {
  5754.     XtSetArg(args[0], XtNlabel, color);
  5755.     }
  5756.     
  5757.     if (((color[0] == 'B') && WhiteOnMove(currentMove))
  5758.     || ((color[0] == 'W') && !WhiteOnMove(currentMove))) {
  5759.     XtSetArg(args[1], XtNbackground, timerForegroundPixel);
  5760.     XtSetArg(args[2], XtNforeground, timerBackgroundPixel);
  5761.     } else {
  5762.     XtSetArg(args[1], XtNbackground, timerBackgroundPixel);
  5763.     XtSetArg(args[2], XtNforeground, timerForegroundPixel);
  5764.     }
  5765.     
  5766.     XtSetValues(w, args, 3);
  5767. }
  5768.  
  5769. char *TimeString(tm)
  5770.      long tm;
  5771. {
  5772.     int second, minute, hour, day;
  5773.     char *sign = "";
  5774.     static char buf[32];
  5775.     
  5776.     if (tm > 0 && tm <= 900) {
  5777.     /* convert milliseconds to tenths, rounding up */
  5778.     sprintf(buf, " 0.%1d ", (tm+99)/100);
  5779.     return buf;
  5780.     }
  5781.  
  5782.     /* convert milliseconds to seconds, rounding up */
  5783.     tm = (tm + 999) / 1000; 
  5784.  
  5785.     if (tm < 0) {
  5786.     sign = "-";
  5787.     tm = -tm;
  5788.     }
  5789.     
  5790.     if (tm >= (60 * 60 * 24)) {
  5791.     day = (int) (tm / (60 * 60 * 24));
  5792.     tm -= day * 60 * 60 * 24;
  5793.     } else {
  5794.     day = 0;
  5795.     }
  5796.     
  5797.     if (tm >= (60 * 60)) {
  5798.     hour = (int) (tm / (60 * 60));
  5799.     tm -= hour * 60 * 60;
  5800.     } else {
  5801.     hour = 0;
  5802.     }
  5803.     
  5804.     if (tm >= 60) {
  5805.     minute = (int) (tm / 60);
  5806.     tm -= minute * 60;
  5807.     } else {
  5808.     minute = 0;
  5809.     }
  5810.     
  5811.     second = tm % 60;
  5812.     
  5813.     if (day > 0)
  5814.       sprintf(buf, " %s%d:%02d:%02d:%02d ", sign, day, hour, minute, second);
  5815.     else if (hour > 0)
  5816.       sprintf(buf, " %s%d:%02d:%02d ", sign, hour, minute, second);
  5817.     else
  5818.       sprintf(buf, " %s%2d:%02d ", sign, minute, second);
  5819.     
  5820.     return buf;
  5821. }
  5822.  
  5823. void Usage()
  5824. {
  5825.     fprintf(stderr, "Usage: %s\n", programName);
  5826.     fprintf(stderr, "\tstandard Xt options\n");
  5827.     fprintf(stderr, "\t-iconic\n");
  5828.     fprintf(stderr, "\t-tc or -timeControl minutes[:seconds]\n");
  5829.     fprintf(stderr, "\t-mps or -movesPerSession moves\n");
  5830.     fprintf(stderr, "\t-st or -searchTime minutes[:seconds]\n");
  5831.     fprintf(stderr, "\t-sd or -searchDepth number\n");
  5832.     fprintf(stderr, "\t-clock or -clockMode (True | False)\n");
  5833.     fprintf(stderr, "\t-autoflag or -autoCallFlag (True | False)\n");
  5834.     fprintf(stderr, "\t-td or -timeDelay seconds\n");
  5835.     fprintf(stderr, "\t-ics or -internetChessServerMode (True | False)\n");
  5836.     fprintf(stderr, "\t-icshost or -internetChessServerHost host_name\n");
  5837.     fprintf(stderr, "\t-icsport or -internetChessServerPort port_number\n");
  5838.     fprintf(stderr, "\t-ncp or -noChessProgram (True | False)\n");
  5839.     fprintf(stderr, "\t-fcp or -firstChessProgram program_name\n");
  5840.     fprintf(stderr, "\t-scp or -secondChessProgram program_name\n");
  5841.     fprintf(stderr, "\t-fh or -firstHost host_name\n");
  5842.     fprintf(stderr, "\t-sh or -secondHost host_name\n");
  5843.     fprintf(stderr, "\t-rsh or -remoteShell shell_name\n");
  5844.     fprintf(stderr,
  5845.         "\t-mm or -matchMode (False | Init | Position | Opening)\n");
  5846.     fprintf(stderr, "\t-lgf or -loadGameFile file_name\n");
  5847.     fprintf(stderr, "\t-sgf or -saveGameFile file_name\n");
  5848.     fprintf(stderr, "\t-autosave or -autoSaveGames (True | False)\n");
  5849.     fprintf(stderr, "\t-lpf or -loadPositionFile file_name\n");
  5850.     fprintf(stderr, "\t-spf or -savePositionFile file_name\n");
  5851.     fprintf(stderr, "\t-bell or -ringBellAfterMoves (True | False)\n");
  5852.     fprintf(stderr, "\t-size or -boardSize (Large | Medium | Small)\n");
  5853.     fprintf(stderr, "\t-coords or -showCoords (True | False)\n");
  5854.     fprintf(stderr, "\t-mono or -monoMode (True | False)\n");
  5855.     fprintf(stderr, "\t-debug or -debugMode (True | False)\n");
  5856.     exit(2);
  5857. }
  5858.  
  5859. /*
  5860.  * This is necessary because some C libraries aren't ANSI C compliant yet.
  5861.  */
  5862. char *StrStr(string, match)
  5863.      char *string, *match;
  5864. {
  5865.     int i, length;
  5866.     
  5867.     length = strlen(match);
  5868.     
  5869.     for (i = strlen(string) - length; i >= 0; i--, string++)
  5870.       if (!strncmp(match, string, (size_t) length))
  5871.     return string;
  5872.     
  5873.     return NULL;
  5874. }
  5875.  
  5876. int StrCaseCmp(s1, s2)
  5877.      char *s1, *s2;
  5878. {
  5879.     char c1, c2;
  5880.     
  5881.     for (;;) {
  5882.     c1 = ToLower(*s1++);
  5883.     c2 = ToLower(*s2++);
  5884.     if (c1 > c2) return 1;
  5885.     if (c1 < c2) return -1;
  5886.     if (c1 == NULLCHAR) return 0;
  5887.     }
  5888. }
  5889.  
  5890.  
  5891. int ToLower(c)
  5892.      int c;
  5893. {
  5894.     return isupper(c) ? tolower(c) : c;
  5895. }
  5896.  
  5897.  
  5898. int ToUpper(c)
  5899.      int c;
  5900. {
  5901.     return islower(c) ? toupper(c) : c;
  5902. }
  5903.  
  5904.  
  5905. #if defined(SYSTEM_FIVE) || defined(SYSV)
  5906. #ifdef    IRIX /*??*/
  5907. char *PseudoTTY(ptyv)
  5908.      int *ptyv;
  5909. {
  5910.     char *line;
  5911.     
  5912.     line = (char *)_getpty(ptyv, O_RDWR, 0600, 0);
  5913.     if (0 == line)
  5914.       return NULL;
  5915.     return line;
  5916. }
  5917. #else    /*!IRIX*/
  5918. char *PseudoTTY(ptyv)
  5919.      int *ptyv;
  5920. {
  5921. #ifdef SVR4
  5922.     char *ptsname(), *ptss;
  5923.     
  5924.     *ptyv = open("/dev/ptmx", O_RDWR);
  5925.     if (*ptyv > 0 ) {
  5926.     if (grantpt(*ptyv) == -1)
  5927.       return NULL;
  5928.     if (unlockpt(*ptyv) == -1)
  5929.       return NULL;
  5930.     if (!(ptss = ptsname(*ptyv)))
  5931.       return NULL;
  5932.     strncpy(ptyname, ptss, sizeof(ptyname));
  5933.     ptyname[sizeof(ptyname) -1] = 0;
  5934.     return ptyname;
  5935.     }
  5936.     
  5937. #else /* !SVR4 */
  5938.     struct stat stb;
  5939.     int c, i;
  5940.     
  5941.     for (c = 'p'; c <= 'z'; c++)
  5942. #if defined(HPUX) || defined(hpux)
  5943.       for (i = 0; i < 15 /*??*/; i++) {
  5944.       sprintf(ptyname, "/dev/ptym/pty%c%x", c, i);
  5945. #else /* !HPUX */
  5946.       for (i = 0; i < 16; i++) {
  5947. #ifdef RTU
  5948.       sprintf(ptyname, "/dev/pty%x", i);
  5949. #else /* !RTU */
  5950.       sprintf(ptyname, "/dev/pty%c%x", c, i);
  5951. #endif /* RTU */
  5952. #endif /* HPUX */
  5953.           
  5954. #ifdef IRIS
  5955.       *ptyv = open("/dev/ptc", O_RDWR, 0);
  5956.       if (*ptyv < 0)
  5957.         return NULL;
  5958.       if (fstat(*ptyv, &stb) < 0)
  5959.         return NULL;
  5960. #else /* !IRIS */
  5961.       if (stat(ptyname, &stb) < 0)
  5962.         return NULL;
  5963.       *ptyv = open(ptyname, O_RDWR, 0);
  5964. #endif /* IRIS */
  5965.           
  5966.       if (*ptyv >= 0) {
  5967. #if defined(HPUX) || defined(hpux)
  5968.           sprintf(ptyname, "/dev/pty/tty%c%x", c, i);
  5969. #else /* !HPUX */
  5970. #ifdef RTU
  5971.           sprintf(ptyname, "/dev/ttyp%x", i);
  5972. #else /* !RTU */
  5973. #ifdef IRIS
  5974.           sprintf(ptyname, "/dev/ttyq%d",
  5975.               minor(stb.st_rdev));
  5976. #else /* !IRIS, !RTU, !HPUX */
  5977.           sprintf(ptyname, "/dev/tty%c%x", c, i);
  5978. #endif /* IRIS */
  5979. #endif /* RTU */
  5980. #endif /* HPUX */
  5981.           
  5982. #ifndef    UNIPLUS
  5983.           if (access(ptyname, 6) != 0) {
  5984.           close(*ptyv);
  5985. #ifdef IRIS
  5986.           return NULL;
  5987. #else /* !IRIS */
  5988.           continue;
  5989. #endif /* IRIS */
  5990.           }
  5991. #endif /* !UNIPLUS */
  5992.           
  5993. #ifdef IBMRTAIX
  5994.           signal(SIGHUP, SIG_IGN);
  5995. #endif /* IBMRTAIX */
  5996.           return ptyname;
  5997.       }
  5998.       }
  5999.       
  6000. #endif
  6001.     return NULL;
  6002. }
  6003. #endif /*IRIX*/
  6004.     
  6005. #else /* !SYSTEM_FIVE */
  6006.     
  6007. void CatchPipeSignal(dummy)
  6008.   int dummy;
  6009. {
  6010.     char message[MSG_SIZ];
  6011.     char *number, *name;
  6012.     
  6013.     if (lastMsgFP == toFirstProgFP) {
  6014.     number = "first";
  6015.     name = appData.firstChessProgram;
  6016.     } else if (lastMsgFP == toSecondProgFP) {
  6017.     number = "second";
  6018.     name = appData.secondChessProgram;
  6019.     } else {
  6020.     return;
  6021.     }
  6022.  
  6023.     sprintf(message,
  6024.         "%s chess program (%s) exited unexpectedly (pipe signal)",
  6025.         number, name);
  6026.     fprintf(stderr, "%s: %s\n", programName, message);
  6027.     ShutdownChessPrograms(message);
  6028.     return;
  6029. }
  6030. #endif
  6031.