"Fossies" - the Fresh Open Source Software Archive

Member "gnuchess-6.2.9/src/frontend/common.h" (4 Jul 2021, 19100 Bytes) of package /linux/privat/gnuchess-6.2.9.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "common.h" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 6.2.8_vs_6.2.9.

    1 /* common.h
    2 
    3    GNU Chess frontend
    4 
    5    Copyright (C) 2001-2020 Free Software Foundation, Inc.
    6 
    7    GNU Chess is based on the two research programs
    8    Cobalt by Chua Kong-Sian and Gazebo by Stuart Cracraft.
    9 
   10    This program is free software: you can redistribute it and/or modify
   11    it under the terms of the GNU General Public License as published by
   12    the Free Software Foundation, either version 3 of the License, or
   13    (at your option) any later version.
   14 
   15    This program is distributed in the hope that it will be useful,
   16    but WITHOUT ANY WARRANTY; without even the implied warranty of
   17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   18    GNU General Public License for more details.
   19 
   20    You should have received a copy of the GNU General Public License
   21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
   22 
   23    Contact Info:
   24      bug-gnu-chess@gnu.org
   25      cracraft@ai.mit.edu, cracraft@stanfordalumni.org, cracraft@earthlink.net
   26 */
   27 
   28 #ifndef COMMON_H
   29 #define COMMON_H
   30 
   31 #include <config.h>
   32 #include <pthread.h>
   33 
   34 #ifndef __GNUC__
   35 # define __attribute__(x)
   36 #endif
   37 
   38 /*
   39  * Include "uint64_t" and similar types using the ac_need_stdint_h ac macro
   40  */
   41 
   42 #include "GCint.h"
   43 
   44 #include <stdio.h>
   45 #include <sys/types.h>
   46 
   47  /*
   48   * Define time structures to get timeval for Timer
   49   */
   50 
   51 #include <sys/time.h>
   52 
   53  /*
   54   * Define macro for declaring 64bit constants for compilers not using ULL
   55   */
   56 
   57 #ifdef _MSC_VER
   58    #define ULL(x) ((uint64_t)(x))
   59 #else
   60    #define ULL(x) x ## ULL
   61 #endif
   62 
   63 /*
   64  * BitBoard is a key data type.  It is a 64-bit value, in which each
   65  * bit represents a square on the board as defined by "enum Square".
   66  * Thus, bit position 0 represents a fact about square a1, and bit
   67  * position 63 represents a fact about square h8.  For example, the
   68  * bitboard representing "white rook" positions will have a bit set
   69  * for every position occupied on the board by a white rook.
   70  */
   71 
   72 typedef uint64_t BitBoard;
   73 typedef uint64_t HashType;
   74 typedef uint32_t KeyType;
   75 
   76 /*
   77  * Board represents an entire board's state, and is structured to
   78  * simplify analysis:
   79  */
   80 
   81 typedef struct
   82 {
   83    BitBoard b[2][7];      /* piece/pawn positions by side (0=white, 1=black)
   84                              and then by piece (1=pawn..6=king). For example,
   85                              b[white][knight] has bits set for every board
   86                              position occupied by a White Knight. */
   87    BitBoard friends[2];   /* Friendly (this side's) pieces */
   88    BitBoard blocker;
   89    BitBoard blockerr90;   /* rotated 90 degrees */
   90    BitBoard blockerr45;   /* rotated 45 degrees */
   91    BitBoard blockerr315;  /* rotated 315 degrees */
   92    short ep;              /* Location of en passant square */
   93    short flag;            /* Flags related to castle privileges */
   94    short side;            /* Color of side on move: 0=white, 1=black */
   95    short material[2];     /* Total material by side not inc. king */
   96    short pmaterial[2];    /* Total pawn material by side not inc. king */
   97    short castled[2];      /* True (1) if side is castled */
   98    short king[2];         /* Location of king 0 - a1 .. 63 - h8 */
   99 } Board;
  100 
  101 /* leaf describes a leaf-level analysis result */
  102 
  103 typedef struct
  104 {
  105    int move;   /* the move that produced this particular board */
  106    int score;  /* the scored value of this leaf */
  107 } leaf;
  108 
  109 /*
  110  * GameRec records an individual move made in the game; an entire
  111  * Game is a set of GameRec's:
  112  */
  113 
  114 #define SANSZ 8 /* longest move is "exf8=Q+" so 7+1 */
  115 
  116 typedef struct
  117 {
  118    int move;    /* The actual move made; this is NOT the move count! */
  119    short epsq;  /* en passant square */
  120    short bflag; /* Flags for castle privs, see Board.flag */
  121    short Game50; /* The last value of GameCnt (a count of half-moves)
  122                     that castled, captured, or moved a pawn */
  123    short mvboard;
  124    float et;     /* elapsed time */
  125    HashType hashkey;
  126    HashType phashkey;
  127    char SANmv[SANSZ];  /* The move in SAN notation */
  128    char *comments;
  129 } GameRec;
  130 
  131 
  132 /*  MACRO definitions */
  133 
  134 #ifndef MAX
  135 #define MAX(a,b)     ((a) > (b) ? (a) : (b))
  136 #endif
  137 #ifndef MIN
  138 #define MIN(a,b)     ((a) < (b) ? (a) : (b))
  139 #endif
  140 #define SET(a,b)                     \
  141   do {                               \
  142     (a) |= (b);                      \
  143     dbg_printf("Set   0x%x\n", (b)); \
  144   } while (0)
  145 #define CLEAR(a,b)                   \
  146   do {                               \
  147     (a) &= ~(b);                     \
  148     dbg_printf("Clear 0x%x\n", (b)); \
  149   } while (0)
  150 
  151 /* Draw score can be used to penalise draws if desired */
  152 #define PHASE        (8 - (board.material[white]+board.material[black]) / 1150)
  153 
  154 /*  Attack MACROS */
  155 
  156 #define BishopAttack(sq) \
  157     (Bishop45Atak[sq][(board.blockerr45 >> Shift45[sq]) & Mask45[sq]] | \
  158      Bishop315Atak[sq][(board.blockerr315 >> Shift315[sq]) & Mask315[sq]])
  159 #define RookAttack(sq)  \
  160     (Rook00Atak[sq][(board.blocker >> Shift00[sq]) & 0xFF] | \
  161          Rook90Atak[sq][(board.blockerr90 >> Shift90[sq]) & 0xFF])
  162 #define QueenAttack(sq) \
  163     (BishopAttack(sq) | RookAttack(sq))
  164 
  165 
  166 /*  Some bit macros  */
  167 
  168 /*
  169  * gcc 2.95.4 completely screws up the macros with lookup tables
  170  * with -O2 on PPC, maybe this check has to be refined. (I don't know
  171  * whether other architectures also suffer from this gcc bug.) However,
  172  * with gcc 3.0, the lookup tables are _much_ faster than this direct
  173  * calculation.
  174  */
  175 #if defined(__GNUC__) && defined(__PPC__) && __GNUC__ < 3
  176 #  define SETBIT(b,i)   ((b) |=  ((ULL(1)<<63)>>(i)))
  177 #  define CLEARBIT(b,i) ((b) &= ~((ULL(1)<<63)>>(i)))
  178 #else
  179 #  define SETBIT(b,i)   ((b) |= BitPosArray[i])
  180 #  define CLEARBIT(b,i) ((b) &= NotBitPosArray[i])
  181 #endif
  182 
  183 #define RANK(i) ((i) >> 3)
  184 #define ROW(i) ((i) & 7)
  185 #define trailz(b) (leadz ((b) & ((~b) + 1)))
  186 
  187 /* Move Descriptions (moves) are represented internally as integers.
  188  * The lowest 6 bits define the destination ("TO") square, and
  189  * the next lowest 6 bits define the source ("FROM") square,
  190  * using the values defined by "enum Square" (0=a1, 63=h8).
  191  * Upper bits are used to identify other move information such as
  192  * a promotion (and to what), a capture (and of what),
  193  * CASTLING moves, and ENPASSANT moves; see the "constants for
  194  * move description" below for more information on these upper bits.
  195  */
  196 #define PROMOTEPIECE(a) ((a >> 12) & 0x0007)
  197 #define CAPTUREPIECE(a) ((a >> 15) & 0x0007)
  198 #define TOSQ(a)         ((a) & 0x003F)
  199 #define FROMSQ(a)       ((a >> 6) & 0x003F)
  200 #define MOVE(a,b)       (((a) << 6) | (b))
  201 
  202 /* constants for move description */
  203 #define KNIGHTPRM     0x00002000
  204 #define BISHOPPRM     0x00003000
  205 #define ROOKPRM       0x00004000
  206 #define QUEENPRM      0x00005000
  207 #define PROMOTION     0x00007000
  208 #define PAWNCAP       0x00008000
  209 #define KNIGHTCAP     0x00010000
  210 #define BISHOPCAP     0x00018000
  211 #define ROOKCAP       0x00020000
  212 #define QUEENCAP      0x00028000
  213 #define CAPTURE       0x00038000
  214 #define NULLMOVE      0x00100000
  215 #define CASTLING      0x00200000
  216 #define ENPASSANT     0x00400000
  217 #define MOVEMASK      (CASTLING | ENPASSANT | PROMOTION | 0x0FFF)
  218 
  219 #define white  0
  220 #define black  1
  221 #define false  0
  222 #define true   1
  223 #define ks 0
  224 #define qs 1
  225 #define MATE      32767
  226 #define MATESCORE(a)    ((a) > MATE-255  || (a) < -MATE+255)
  227 
  228 /* constants for Board */
  229 #define WKINGCASTLE   0x0001
  230 #define WQUEENCASTLE  0x0002
  231 #define BKINGCASTLE   0x0004
  232 #define BQUEENCASTLE  0x0008
  233 #define WCASTLE       (WKINGCASTLE | WQUEENCASTLE)
  234 #define BCASTLE       (BKINGCASTLE | BQUEENCASTLE)
  235 
  236 /* Material values */
  237 #define ValueP   100
  238 #define ValueN   350
  239 #define ValueB   350
  240 #define ValueR   550
  241 #define ValueQ   1100
  242 #define ValueK   2000
  243 
  244 
  245 /*  Some special BitBoards  */
  246 #define NULLBITBOARD  ( ULL(0x0000000000000000))
  247 #define WHITESQUARES  ( ULL(0x55AA55AA55AA55AA))
  248 #define BLACKSQUARES  ( ULL(0xAA55AA55AA55AA55))
  249 #define CENTRESQUARES ( ULL(0x0000001818000000))
  250 #define COMPUTERHALF  ( ULL(0xFFFFFFFF00000000))
  251 #define OPPONENTHALF  ( ULL(0x00000000FFFFFFFF))
  252 
  253 /*  Game flags */
  254 #define QUIT    0x0001
  255 #define TESTT   0x0002
  256 #define THINK   0x0004
  257 #define MANUAL  0x0008
  258 #define TIMEOUT 0x0010
  259 #define UCI     0x0020
  260 #define WEAK    0x0020
  261 #define ENDED   0x0040
  262 #define USEHASH 0x0080
  263 #define SOLVE   0x0100
  264 #define USENULL 0x0200
  265 #define XBOARD  0x0400
  266 #define TIMECTL 0x0800
  267 #define POST    0x1000
  268 #define PONDER  0x2000 /* We are in pondering (during search) */
  269 #define HARD    0x4000 /* Pondering is turned on */
  270 #define ANALYZE 0x8000 /* In ANALYZE mode */
  271 
  272 /*  Book modes */
  273 #define BOOKOFF 0
  274 #define BOOKRAND 1
  275 #define BOOKBEST 2
  276 #define BOOKWORST 3
  277 #define BOOKPREFER 4
  278 
  279 #define MAXTREEDEPTH  2000
  280 #define MAXPLYDEPTH   65
  281 #define MAXGAMEDEPTH  600
  282 
  283 #define R_WHITE_WINS 1
  284 #define R_BLACK_WINS 2
  285 #define R_DRAW 3
  286 #define R_NORESULT 4
  287 
  288 extern unsigned char lzArray[65536];
  289 extern short Shift00[64];
  290 extern short Shift90[64];
  291 extern short Shift45[64];
  292 extern short Shift315[64];
  293 extern BitBoard BitPosArray[64];
  294 extern BitBoard NotBitPosArray[64];
  295 extern BitBoard MoveArray[8][64];
  296 extern BitBoard Ray[64][8];
  297 extern BitBoard FromToRay[64][64];
  298 extern BitBoard RankBit[8];
  299 extern BitBoard FileBit[8];
  300 extern BitBoard Ataks[2][7];
  301 extern BitBoard Rook00Atak[64][256];
  302 extern BitBoard Rook90Atak[64][256];
  303 extern BitBoard Bishop45Atak[64][256];
  304 extern BitBoard Bishop315Atak[64][256];
  305 extern short directions[64][64];
  306 extern unsigned char BitCount[65536];
  307 extern leaf Tree[MAXTREEDEPTH];
  308 extern leaf *TreePtr[MAXPLYDEPTH];
  309 extern GameRec Game[MAXGAMEDEPTH];
  310 extern int RealGameCnt;
  311 extern short RealSide;
  312 extern int GameCnt;
  313 extern int computer;
  314 extern unsigned int flags;
  315 extern unsigned int preanalyze_flags;
  316 extern Board board;
  317 extern int cboard[64];
  318 extern int Mvboard[64];
  319 extern HashType hashcode[2][7][64];
  320 extern HashType ephash[64];
  321 extern HashType WKCastlehash;
  322 extern HashType WQCastlehash;
  323 extern HashType BKCastlehash;
  324 extern HashType BQCastlehash;
  325 extern HashType Sidehash;
  326 extern HashType HashKey;
  327 extern HashType PawnHashKey;
  328 extern int Game50;
  329 extern unsigned long GenCnt;
  330 extern int slider[8];
  331 extern int Value[7];
  332 extern char SANmv[SANSZ];
  333 extern char id[32];
  334 extern char solution[64];
  335 extern float SearchTime;
  336 extern int MoveLimit[2];
  337 extern float TimeLimit[2];
  338 extern int TCMove;
  339 extern int TCinc;
  340 extern float TCTime;
  341 extern int phase;
  342 
  343 extern short bookfirstlast;
  344 extern short graphicmodeoutput;
  345 extern short coords;
  346 extern short pgnloaded; /* was pgn game loaded by command pgnreplay */
  347 extern int pgncnt; /* total moves loaded in pgn game */
  348 
  349 extern int range[8];
  350 extern int ptype[2];
  351 extern char algbr[64][3];
  352 extern char algbrfile[9];
  353 extern char algbrrank[9];
  354 extern char notation[8];
  355 extern char lnotation[8];
  356 extern int r90[64];
  357 extern int r45[64];
  358 extern int r315[64];
  359 extern int Mask45[64];
  360 extern int Mask315[64];
  361 
  362 extern char *progname;
  363 extern FILE *ofp;
  364 extern int myrating, opprating;
  365 
  366 #define MAXNAMESZ 50
  367 extern char name[MAXNAMESZ];
  368 extern int computerplays;
  369 extern int n;       /* Last mobility returned by CTL */
  370 extern int ExchCnt[2];
  371 
  372 enum Piece { empty, pawn, knight, bishop, rook, queen, king, bpawn };
  373 
  374 enum Square { A1, B1, C1, D1, E1, F1, G1, H1,
  375           A2, B2, C2, D2, E2, F2, G2, H2,
  376           A3, B3, C3, D3, E3, F3, G3, H3,
  377           A4, B4, C4, D4, E4, F4, G4, H4,
  378           A5, B5, C5, D5, E5, F5, G5, H5,
  379           A6, B6, C6, D6, E6, F6, G6, H6,
  380           A7, B7, C7, D7, E7, F7, G7, H7,
  381           A8, B8, C8, D8, E8, F8, G8, H8 };
  382 
  383 enum File { A_FILE, B_FILE, C_FILE, D_FILE, E_FILE, F_FILE, G_FILE, H_FILE };
  384 
  385 /****************************************************************************
  386  *
  387  *  The various function prototypes.  They are group into the *.c files
  388  *  in which they are defined.
  389  *
  390  ****************************************************************************/
  391 
  392 /*
  393  * Explanation of the #ifdef NO_INLINE conditionals:
  394  *
  395  * Define NO_INLINE only if you really must, implementations will be
  396  * provided by the corresponding *.c files. The better solution is to
  397  * not define it, in which case inlines.h will be included which
  398  * provides static inline version of these functions.
  399  */
  400 
  401 /*  The initialization routines  */
  402 void Initialize (void);
  403 void InitLzArray (void);
  404 void InitBitPosArray (void);
  405 void InitMoveArray (void);
  406 void InitRay (void);
  407 void InitFromToRay (void);
  408 void InitRankFileBit (void);
  409 void InitBitCount (void);
  410 void InitPassedPawnMask (void);
  411 void InitIsolaniMask (void);
  412 void InitSquarePawnMask (void);
  413 void InitRandomMasks (void);
  414 void InitRotAtak (void);
  415 void InitDistance (void);
  416 void InitVars (void);
  417 void InitHashCode (void);
  418 void InitHashTable (void);
  419 void NewPosition (void);
  420 void InitInput (void);
  421 
  422 /*  The move generation routines  */
  423 void GenMoves (short);
  424 void GenCaptures (short);
  425 void GenNonCaptures (short);
  426 void GenCheckEscapes (short);
  427 void FilterIllegalMoves (short);
  428 
  429 /*  The move routines  */
  430 void MakeMove (int, int *);
  431 void UnmakeMove (int, int *);
  432 void SANMove (int, int);
  433 leaf *ValidateMove (char *, char *cleanMove=0);
  434 leaf *IsInMoveList (int, int, int, char);
  435 char *AlgbrMove (int);
  436 
  437 /*  The attack routines  */
  438 short SqAtakd (short sq, short side);
  439 BitBoard AttackTo (int, int);
  440 int PinnedOnKing (int, int);
  441 
  442 /*  The swap routines  */
  443 int SwapOff (int);
  444 void AddXrayPiece (int, int, int, BitBoard *, BitBoard *);
  445 
  446 /*  The EPD routines  */
  447 short ReadEPDFile (const char *, short);
  448 int ParseEPD (char *);
  449 void LoadEPD (char *);
  450 void SaveEPD (char *);
  451 void EPD2str (char *);
  452 
  453 /* Error codes for ParseEPD */
  454 enum {
  455    EPD_SUCCESS,
  456    EPD_ERROR
  457 };
  458 
  459 void UpdateFriends (void);
  460 void UpdateCBoard (void);
  461 void UpdateMvboard (void);
  462 short ValidateBoard (void);
  463 
  464 /*  PGN routines  */
  465 void PGNSaveToFile (const char *, const char *);
  466 void PGNReadFromFile (const char *, int showheading);
  467 
  468 /*  Some output routines */
  469 void ShowMoveList (int);
  470 void ShowBoard (void);
  471 void ShowCBoard (void);
  472 void ShowMvboard (void);
  473 
  474 void ShowGame (void);
  475 void ShowTime (void);
  476 
  477 /*  Solver routines  */
  478 void Solve (char *);
  479 
  480 /* Player database */
  481 void DBSortPlayer (const char *style);
  482 void DBListPlayer (const char *style);
  483 void DBReadPlayer (void);
  484 void DBWritePlayer (void);
  485 int DBSearchPlayer (const char *player);
  486 void DBUpdatePlayer (const char *player, const char *resultstr);
  487 
  488 /* Input thread and thread function */
  489 extern pthread_t input_thread;
  490 void *input_func(void *);
  491 
  492 /*
  493  * Status variable used by the input thread to signal
  494  * pending input. Thought about using flags for this
  495  * but this can be refined and is conceptually different
  496  * from flags.
  497  */
  498 enum {
  499   INPUT_NONE,
  500   INPUT_AVAILABLE
  501 };
  502 extern volatile int input_status;
  503 
  504 /*
  505  * Function to wake up the input thread, should be called after
  506  * input has been parsed.
  507  */
  508 void input_wakeup(void);
  509 
  510 /* Wait for input. */
  511 
  512 //void wait_for_input(void);
  513 
  514 /*
  515  * Input routine, initialized to one of the specific
  516  * input routines. The given argument is the prompt.
  517  */
  518 extern void (*get_line) (char *);
  519 
  520 #define BUF_SIZE 4096
  521 
  522 #define MAXSTR 128
  523 extern char inputstr[BUF_SIZE];
  524 
  525 /* Input parser */
  526 void parse_input(void);
  527 
  528 /* Check Board to avoid analysis of incorrectly input positions */
  529 void check_board(void);
  530 
  531 /* Commands from the input engine */
  532 void cmd_activate(void);
  533 void cmd_analyze(void);
  534 void cmd_bk(void);
  535 void cmd_black(void);
  536 void cmd_book(void);
  537 void cmd_computer(void);
  538 void cmd_depth(void);
  539 void cmd_draw(void);
  540 void cmd_easy(void);
  541 void cmd_edit(void);
  542 void cmd_epd(void);
  543 void cmd_exit(void);
  544 void cmd_force(void);
  545 void cmd_go(void);
  546 void cmd_graphic(void);
  547 void cmd_hard(void);
  548 void cmd_hash(void);
  549 void cmd_help (void);
  550 void cmd_hint(void);
  551 void cmd_last(void);
  552 void cmd_level(void);
  553 void cmd_list(void);
  554 void cmd_load(void);
  555 void cmd_manual(void);
  556 void cmd_movenow(void);
  557 void cmd_name(void);
  558 void cmd_next(void);
  559 void cmd_new(void);
  560 void cmd_nographic(void);
  561 void cmd_nopost(void);
  562 void cmd_null(void);
  563 void cmd_otim(void);
  564 void cmd_pgnload(void);
  565 void cmd_pgnreplay(void);
  566 void cmd_pgnsave(void);
  567 void cmd_ping(void);
  568 void cmd_post(void);
  569 void cmd_previous(void);
  570 void cmd_first(void);
  571 void cmd_protover(void);
  572 void cmd_quit(void);
  573 void cmd_random(void);
  574 void cmd_rating(void);
  575 void cmd_rejected(void);
  576 void cmd_remove(void);
  577 void cmd_result(void);
  578 void cmd_save(void);
  579 void cmd_setboard(void);
  580 void cmd_show (void);
  581 void cmd_solve(void);
  582 void cmd_st(void);
  583 void cmd_switch(void);
  584 void cmd_test (void);
  585 void cmd_time(void);
  586 void cmd_undo(void);
  587 void cmd_usage(void);
  588 void cmd_variant(void);
  589 void cmd_version(void);
  590 void cmd_white(void);
  591 void cmd_xboard(void);
  592 
  593 
  594 /*
  595  * Define NO_INLINE only if you really must, implementations will be
  596  * provided by the corresponding *.c files. The better solution is to
  597  * not define it, in which case inlines.h will be included which
  598  * provides static inline version of these functions.
  599  */
  600 
  601 /*  Some utility routines  */
  602 #ifdef NO_INLINE
  603 unsigned char leadz (BitBoard);
  604 unsigned char nbits (BitBoard);
  605 #else
  606 # include "inlines.h"
  607 #endif
  608 
  609 /* More elaborate debugging output to logfile */
  610 
  611 /* All the following functions are no-ops if DEBUG is not defined */
  612 
  613 /*
  614  * dbg_open() can be called with NULL as argument, using a default
  615  * filename, defined in debug.c, for the debug log. Otherwise the
  616  * argument is the filename. If dbg_open() fails or is not called at
  617  * all, debugging output goes to stderr by default.
  618  */
  619 int dbg_open(const char *name);
  620 
  621 /* Same format rules as printf() */
  622 int dbg_printf(const char *fmt, ...);
  623 
  624 /* Closes the debugging log, if it is not stderr */
  625 int dbg_close(void);
  626 
  627 # ifdef DEBUG
  628 #  include <assert.h>
  629 #  define ASSERT(x) assert(x)
  630 # else
  631 #  define ASSERT(x)
  632 # endif
  633 
  634 /*
  635  * Initializes data used in the frontend.
  636  */
  637 void InitFrontend( void );
  638 
  639 /*
  640  * Reads a char string entered by the user.
  641 */
  642 void ReadFromUser( void );
  643 
  644 /*
  645  * Sends a message to the adapter/engine.
  646 */
  647 int SendToEngine( char msg[] );
  648 
  649 /*
  650  * Reads a char string message from the adapter/engine.
  651 */
  652 int ReadFromEngine( void );
  653 
  654 /*
  655  * Saves in global variable 'dataToEngine' the data to be sent to the engine.
  656  */
  657 void SetDataToEngine( const char data[] );
  658 
  659 /*
  660  * Stores in a global flag variable whether an answer is expected from
  661  * the engine (1) or not (0).
  662  */
  663 void ExpectAnswerFromEngine( int );
  664 
  665 /*
  666  * Extracts a command from the user input buffer.
  667  */
  668 void NextUserCmd( void );
  669 
  670 /*
  671  * Extracts a command from the engine input buffer.
  672  */
  673 void NextEngineCmd( void );
  674 
  675 /*
  676  * Stores in a global flag variable whether an input from the user is a
  677  * valid move (1) or not (0).
  678  */
  679 void SetUserInputValidMove( int valid );
  680 
  681 /*
  682  * Flags whether the color must be changed, e.g. due to an undo command.
  683  */
  684 void ChangeColor( int change );
  685 
  686 /*
  687  * Sets the autoGo flag, meaning that after a user move a go command will be
  688  * sent to the engine. This may be necessary after an undo.
  689  */
  690 void SetAutoGo( int go );
  691 
  692 /*
  693  * Checks whether the autoGo flag is set or not.
  694  */
  695 int GetAutoGo( void );
  696 
  697 /*
  698  * Reads a char string entered by the user.
  699  * The string must be a command or a move.
  700  * The string is sent to the engine straight away.
  701  */
  702 void ForwardUserInputToEngine( void );
  703 
  704 /*
  705  * Reads a char string message from the engine.
  706  * The message is output'd straight away.
  707  */
  708 void ForwardEngineOutputToUser( void );
  709 
  710 #endif /* !COMMON_H */