/*
 * common.h -- Common definitions for X and Windows NT versions of XBoard
 * $Id: common.h,v 2.1 2003/10/27 19:21:00 mann Exp $
 *
 * Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts.
 * Enhancements Copyright 1992-95 Free Software Foundation, Inc.
 *
 * The following terms apply to Digital Equipment Corporation's copyright
 * interest in XBoard:
 * ------------------------------------------------------------------------
 * All Rights Reserved
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose and without fee is hereby granted,
 * provided that the above copyright notice appear in all copies and that
 * both that copyright notice and this permission notice appear in
 * supporting documentation, and that the name of Digital not be
 * used in advertising or publicity pertaining to distribution of the
 * software without specific, written prior permission.
 *
 * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
 * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 * ------------------------------------------------------------------------
 *
 * The following terms apply to the enhanced version of XBoard distributed
 * by the Free Software Foundation:
 * ------------------------------------------------------------------------
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 * ------------------------------------------------------------------------
 */

#ifndef _COMMON
#define _COMMON

/* Begin compatibility grunge  */

#if defined(__STDC__) || defined(WIN32) || defined(_amigados)
#define	P(args)	args
typedef void *VOIDSTAR;
#else
#define P(args)		()
typedef char *VOIDSTAR;
#endif

#ifdef WIN32
typedef char Boolean;
typedef char *String;
#define popen _popen
#define pclose _pclose

#else
#ifdef _amigados        /*  It is important, that these types have  */
typedef int Boolean;    /*  a length of 4 bytes each, as we are     */
typedef char *String;   /*  using ReadArgs() for argument parsing.  */
#ifdef _DCC
FILE *popen(const char *, const char *);
int pclose(FILE *);
#endif

#else
#include <X11/Intrinsic.h>
#endif
#endif


#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif

#if !HAVE_RANDOM
# if HAVE_RAND48
#  define srandom srand48
#  define random lrand48
# else /* not HAVE_RAND48 */
#  define srandom srand
#  define random rand
# endif /* not HAVE_RAND48 */
#endif /* !HAVE_RANDOM */

/* End compatibility grunge */

#define PROTOVER                2       /* engine protocol version */

#define BOARD_SIZE		8
#define DROP_RANK               -3
#define MAX_MOVES		1000
#define MSG_SIZ			512
#define DIALOG_SIZE		256
#define STAR_MATCH_N            16
#define MOVE_LEN		32
#define TIME_CONTROL		"5"	/* in minutes */
#define TIME_DELAY_QUOTE	"1.0"	/* seconds between moves */
#define TIME_DELAY              ((float) 1.0)
#define MOVES_PER_SESSION	40	/* moves per TIME_CONTROL */
#define TIME_INCREMENT          -1      /* if >= 0, MOVES_PER_SESSION unused */
#define WhiteOnMove(move)	(((move) % 2) == 0)
#define ICS_HOST                "chessclub.com"
#define ICS_PORT	        "5000"
#define ICS_COMM_PORT           ""
#define FIRST_HOST		"localhost"
#define SECOND_HOST		"localhost"
#define TELNET_PROGRAM          "telnet"
#define MATCH_MODE		"False"
#define INIT_STRING		"new\nrandom\n"
#define WHITE_STRING		"white\ngo\n"
#define BLACK_STRING		"black\ngo\n"
#define COMPUTER_STRING         "computer\n"
#define REUSE_CHESS_PROGRAMS    1
#define WHITE_PIECE_COLOR	"#FFFFCC"
#define BLACK_PIECE_COLOR	"#202020"
#define LIGHT_SQUARE_COLOR	"#C8C365"
#define DARK_SQUARE_COLOR	"#77A26D"
#define JAIL_SQUARE_COLOR       "#808080"
#define HIGHLIGHT_SQUARE_COLOR	"#FFFF00"
#define PREMOVE_HIGHLIGHT_COLOR	"#FF0000"
#define BELLCHAR                '\007'
#define NULLCHAR                '\000'
#define FEATURE_TIMEOUT         10000 /*ms*/

/* Zippy defaults */
#define ZIPPY_TALK FALSE
#define ZIPPY_PLAY FALSE
#define ZIPPY_LINES "yow.lines"
#define ZIPPY_PINHEAD ""
#define ZIPPY_PASSWORD ""
#define ZIPPY_PASSWORD2 ""
#define ZIPPY_WRONG_PASSWORD ""
#define ZIPPY_ACCEPT_ONLY ""
#define ZIPPY_USE_I TRUE
#define ZIPPY_BUGHOUSE 0
#define ZIPPY_NOPLAY_CRAFTY FALSE
#define ZIPPY_GAME_END "gameend\n"
#define ZIPPY_GAME_START ""
#define ZIPPY_ADJOURN FALSE
#define ZIPPY_ABORT FALSE
#define ZIPPY_VARIANTS "normal"
#define ZIPPY_MAX_GAMES 0
#define ZIPPY_REPLAY_TIMEOUT 120

typedef enum {
    BeginningOfGame, MachinePlaysWhite, MachinePlaysBlack,
    AnalyzeMode, AnalyzeFile, TwoMachinesPlay,
    EditGame, PlayFromGameFile, EndOfGame, EditPosition, Training,
    IcsIdle, IcsPlayingWhite, IcsPlayingBlack, IcsObserving,
    IcsExamining
  } GameMode;

typedef enum {
    WhitePawn, WhiteKnight, WhiteBishop, WhiteRook, WhiteQueen, WhiteKing,
    BlackPawn, BlackKnight, BlackBishop, BlackRook, BlackQueen, BlackKing,
    EmptySquare, 
    ClearBoard, WhitePlay, BlackPlay /*for use on EditPosition menus*/
  } ChessSquare;

typedef ChessSquare Board[BOARD_SIZE][BOARD_SIZE];

typedef enum {
    WhiteKingSideCastle = 1, WhiteQueenSideCastle,
    WhiteKingSideCastleWild, WhiteQueenSideCastleWild,
    WhiteHSideCastleFR, WhiteASideCastleFR, 
    BlackKingSideCastle, BlackQueenSideCastle,
    BlackKingSideCastleWild, BlackQueenSideCastleWild,
    BlackHSideCastleFR, BlackASideCastleFR, 
    WhitePromotionKnight, WhitePromotionBishop,
    WhitePromotionRook, WhitePromotionQueen, WhitePromotionKing,
    BlackPromotionKnight, BlackPromotionBishop,
    BlackPromotionRook, BlackPromotionQueen, BlackPromotionKing,
    WhiteCapturesEnPassant, BlackCapturesEnPassant,
    WhiteDrop, BlackDrop, 
    NormalMove, AmbiguousMove, IllegalMove, ImpossibleMove,
    WhiteWins, BlackWins, GameIsDrawn, GameUnfinished,
    GNUChessGame, XBoardGame, MoveNumberOne, 
    Comment, PositionDiagram, ElapsedTime, PGNTag, NAG
  } ChessMove;

typedef enum {
    ColorShout, ColorSShout, ColorChannel1, ColorChannel, ColorKibitz,
    ColorTell, ColorChallenge, ColorRequest, ColorSeek, ColorNormal,
    ColorNone, NColorClasses
} ColorClass;

typedef enum {
    SoundMove, SoundBell, SoundAlarm, SoundIcsWin, SoundIcsLoss,
    SoundIcsDraw, SoundIcsUnfinished, NSoundClasses
} SoundClass;

/* Names for chess variants, not necessarily supported */
typedef enum {
    VariantNormal,       /* Normal chess */
    VariantLoadable,     /* "loadgame" command allowed (not really a variant)*/
    VariantWildCastle,   /* Shuffle chess where king can castle from d file */
    VariantNoCastle,     /* Shuffle chess with no castling at all */
    VariantFischeRandom, /* FischeRandom */
    VariantBughouse,     /* Bughouse, ICC/FICS rules */
    VariantCrazyhouse,   /* Crazyhouse, ICC/FICS rules */
    VariantLosers,       /* Try to lose all pieces or get mated (ICC wild 17)*/
    VariantSuicide,      /* Try to lose all pieces incl. king (FICS) */
    VariantGiveaway,     /* Try to have no legal moves left (ICC wild 26) */
    VariantTwoKings,     /* Weird ICC wild 9 */
    VariantKriegspiel,   /* Kriegspiel; pawns can capture invisible pieces */
    VariantAtomic,       /* Capturing piece explodes (ICC wild 27) */
    Variant3Check,       /* Win by giving check 3 times (ICC wild 25) */
    VariantShatranj,     /* Unsupported (ICC wild 28) */
    Variant29,           /* Temporary name for possible future ICC wild 29 */
    Variant30,           /* Temporary name for possible future ICC wild 30 */
    Variant31,           /* Temporary name for possible future ICC wild 31 */
    Variant32,           /* Temporary name for possible future ICC wild 32 */
    Variant33,           /* Temporary name for possible future ICC wild 33 */
    Variant34,           /* Temporary name for possible future ICC wild 34 */
    Variant35,           /* Temporary name for possible future ICC wild 35 */
    Variant36,           /* Temporary name for possible future ICC wild 36 */
    VariantUnknown       /* Catchall for other unknown variants */
} VariantClass;

#define VARIANT_NAMES { \
  "normal", \
  "normal", \
  "wildcastle", \
  "nocastle", \
  "fischerandom", \
  "bughouse", \
  "crazyhouse", \
  "losers", \
  "suicide", \
  "giveaway", \
  "twokings", \
  "kriegspiel", \
  "atomic", \
  "3check", \
  "shatranj", \
  "wild29", \
  "wild30", \
  "wild31", \
  "wild32", \
  "wild33", \
  "wild34", \
  "wild35", \
  "wild36", \
  "unknown" \
}

// AppData, la estructura de datos más importante
// de todo el programa
typedef struct {
#if !defined(_amigados)
    char *whitePieceColor;
    char *blackPieceColor;
    char *lightSquareColor;
    char *darkSquareColor;
    char *jailSquareColor;
    char *highlightSquareColor;
    char *premoveHighlightColor;
#else
    int whitePieceColor;
    int blackPieceColor;
    int lightSquareColor;
    int darkSquareColor;
    int jailSquareColor;
    int highlightSquareColor;
    int premoveHighlightColor;
#endif
    int movesPerSession;
    int timeIncrement;
    char *initString;
    char *secondInitString;
    char *firstComputerString;
    char *secondComputerString;
    char *firstChessProgram;		// nombre propio del primer programa
    char *secondChessProgram;		// nombre propio del segundo programa
    char *firstDirectory;
    char *secondDirectory;
    Boolean firstPlaysBlack;
    Boolean noChessProgram;
    char *firstHost;
    char *secondHost;
    char *bitmapDirectory;
    char *remoteShell;
    char *remoteUser;
    float timeDelay;
    char *timeControl;
    Boolean icsActive;
    char *icsHost;
    char *icsPort;
    char *icsCommPort;  /* if set, use serial port instead of tcp host/port */
    char *icsLogon;     /* Hack to permit variable logon scripts. */
    char *icsHelper;
    Boolean icsInputBox;
    Boolean useTelnet;
    char *telnetProgram;
    char *gateway;
    char *loadGameFile;
    int loadGameIndex;      /* game # within file */
    char *saveGameFile;
    Boolean autoSaveGames;
    char *loadPositionFile;
    int loadPositionIndex;  /* position # within file */
    char *savePositionFile;
    Boolean matchMode;
    int matchGames;
    Boolean monoMode;
    Boolean debugMode;
    Boolean clockMode;
    char *boardSize;
    Boolean Iconic;
    char *searchTime;
    int searchDepth;
    Boolean showCoords;
    char *clockFont;
    char *messageFont; /* WinBoard only */
    char *coordFont;
    char *font; /* xboard only: all other fonts */
    char *tagsFont; /* WinBoard only */
    char *commentFont; /* WinBoard only */
    char *icsFont; /* WinBoard only */
    Boolean ringBellAfterMoves;
    Boolean autoCallFlag;
    Boolean flipView;
    Boolean autoFlipView;
    char *cmailGameName; /* xboard only */
    Boolean alwaysPromoteToQueen;
    Boolean oldSaveStyle;
//
	 Boolean diagram;		// inclusión de diagrama textual
//
    Boolean quietPlay;
    Boolean showThinking;	// ver las cogitaciones del contrincante
    Boolean ponderNextMove;
    Boolean periodicUpdates;
    Boolean autoObserve;
    Boolean autoComment;
    Boolean getMoveList;
    Boolean testLegality;
    int borderXoffset; /* xboard only */
    int borderYoffset; /* xboard only */
    Boolean titleInWindow; /* xboard only */
    Boolean localLineEditing; /* WinBoard only */
    Boolean zippyTalk;
    Boolean zippyPlay;
    int flashCount; /* Number of times to flash (xboard only) */
    int flashRate; /* Flashes per second (xboard only)  */
    char *pixmapDirectory; /* Path to XPM/XIM files to use (xboard only) */
    int msLoginDelay;  /* Delay per character (in msec) while sending
			  ICS logon script (xboard only) */
    Boolean colorize;	/* If True, use the following colors to color text */
    /* Strings for colors, as "fg, bg, bold" (strings used in xboard only) */
    char *colorShout;
    char *colorSShout;
    char *colorChannel1;
    char *colorChannel;
    char *colorKibitz;
    char *colorTell;
    char *colorChallenge;
    char *colorRequest;
    char *colorSeek;
    char *colorNormal;
    char *soundProgram; /* sound-playing program */
    char *soundShout;
    char *soundSShout;
    char *soundChannel1;
    char *soundChannel;
    char *soundKibitz;
    char *soundTell;
    char *soundChallenge;
    char *soundRequest;
    char *soundSeek;
    char *soundMove;
    char *soundIcsWin;
    char *soundIcsLoss;
    char *soundIcsDraw;
    char *soundIcsUnfinished;
    char *soundIcsAlarm;
    Boolean reuseFirst;
    Boolean reuseSecond;
    Boolean animateDragging; /* If True, animate mouse dragging of pieces */
    Boolean animate;	/* If True, animate non-mouse moves */
    int animSpeed;	/* Delay in milliseconds between animation frames */
    Boolean popupMoveErrors;
    Boolean popupExitMessage;
    int showJail;
    Boolean highlightLastMove;
    Boolean highlightDragging;
    Boolean blindfold;          /* if true, no pieces are drawn */
    Boolean premove;		/* true if premove feature enabled */ 
    Boolean premoveWhite;	/* true if premoving White first move  */ 
    char *premoveWhiteText;	/* text of White premove 1 */ 
    Boolean premoveBlack;	/* true if premoving Black first move */ 
    char *premoveBlackText;	/* text of Black premove 1 */ 
    Boolean icsAlarm;		/* true if sounding alarm at a certain time */	
    int icsAlarmTime;		/* time to sound alarm, in milliseconds */
    Boolean autoRaiseBoard;
    int fontSizeTolerance; /* xboard only */
    char *initialMode;
    char *variant;
    int firstProtocolVersion;
    int secondProtocolVersion;
    Boolean showButtonBar;
//
    Boolean showHistory;
//

#if ZIPPY
    char *zippyLines;
    char *zippyPinhead;
    char *zippyPassword;
    char *zippyPassword2;
    char *zippyWrongPassword;
    char *zippyAcceptOnly;
    int zippyUseI;
    int zippyBughouse;
    int zippyNoplayCrafty;
    char *zippyGameEnd;
    char *zippyGameStart;
    int zippyAdjourn;
    int zippyAbort;
    char *zippyVariants;
    int zippyMaxGames;
    int zippyReplayTimeout; /*seconds*/
#endif
} AppData, *AppDataPtr;

extern AppData appData;

typedef struct {
    /* PGN 7-tag info */
    char * event;
    char * site;
    char * date;
    char * round;
    char * white;
    char * black;
    ChessMove result;
    /* Additional info */
    char * fen;          /* NULL or FEN for starting position; input only */
    char * resultDetails;
    char * timeControl;
    char * extraTags;    /* NULL or "[Tag \"Value\"]\n", etc. */
    int whiteRating;    /* -1 if unknown */
    int blackRating;    /* -1 if unknown */
    VariantClass variant;
} GameInfo;


// (FG)

/* Estas dos son funciones de T. Mann,
   pero no declaradas por él */
int myrandom(void);
void mysrandom(unsigned int seed);


#define READ 0		/* apertura de un fichero para leerlo solo */
#define APPEND 1		/* apertura de un fichero para añadir datos */
#define OVERWRITE 2		/* apertura de un fichero sobrescribiendo */

typedef struct
{
	Boolean recorded;	// if true, the game is related with a disk file
	Boolean modified;	// if true, different from the disk version 
	Boolean replace;	// if false, copy after the initial version
	char inFile[MSG_SIZ];	// full path of the file wich contains it
	FILE * opened;		// circumstances for accessing the file
	unsigned long firstInsertionPoint;	// start of the recorded game
							// (number of bytes from start of file)
	unsigned long secondInsertionPoint;	// start of next recorded game
							// (number of bytes from start of file)
	int serialNumber;	// position of the game in the list
							// (starting from 1)
	int totalNumber;	// number of games in the file (starting from 1)
	int lastSelected;	// value of 'button2' in last selection
} CurrentGame;

extern CurrentGame currentGame;

// variables required for translated versions

extern Boolean toTranslate;
extern char standardPieceSymbols[];
extern char standardColorSymbols[];
extern char localPieceSymbols[];
extern char localColorSymbols[];

// sartas de mensaje

extern char alreadyFEN[];
extern char alreadyMoved[];
extern char ambiguousMove[];
extern char ambiguousICSMove[];
extern char analistSt[];
extern char analysisSt[];
extern char analysisDisplay[];
extern char analysisDisplayB[];
extern char analysisDisplayC[];
extern char analyzeGame[];
extern char atEnd[];
extern char badClipboard[];
extern char badFenPosition[];
extern char badGameFile[];
extern char badMoveType[];
extern char badOption[];
extern char badPositionFile[];
extern char badTimeControl[];
extern char badVersion[];
extern char bishopSt[];
extern char blackSt[];
extern char blackN[];
extern char blackFlagFell[];
extern char blackMates[];
extern char blackResigns[];
extern char blackToPlay[];
extern char blackTurn[];
extern char blackTimeWin[];
extern char bothFlagsFell[];
extern char bothTimeOut[];
extern char browseForAuto[];
extern char browseForSound[];
extern char chessEngineRequired[];
extern char chooseOption[];
extern char closedConnection[];
extern char closeFileError[];
extern char cmailFailure[];
extern char commentSt[];
extern char commentOn[];
extern char commPortAbort[];
extern char commPortFailure[];
extern char conversionDone[];
extern char conversionTitle1[];
extern char conversionTitle2[];
extern char copyError[];
extern char CPStart[];
extern char deEntre[];
extern char directCommand[];
extern char drawSt[];
extern char drawAccepted[];
extern char drawAgreed[];
extern char drawDeclined[];
extern char drawOffered[];
extern char edComment[];
extern char editCommentOn[];
extern char editTags[];
extern char endOfGame[];
extern char errorCode[];
extern char errorFileDialog[];
extern char examiningWarn[];
extern char exitError[];
extern char exitingMess[];
extern char extraBoardError[];
extern char failFileCreate[];
extern char failFileOpen[];
extern char falseSt[];
extern char fatalError[];
extern char firstGame[];
extern char fileToExplore[];
extern char fileToSave[];
extern char firstPosition[];
extern char firstSt[];
extern char fontNameLong[];
extern char fontSizeMissing[];
extern char forfeitIllegalMove[];
extern char gameAborted[];
extern char gameFileRequired[];
extern char gameHistoryModified[];
extern char gameNotFound[];
extern char gamesSt[];
extern char gameTooLong[];
extern char gapList[];
extern char hintSt[];
extern char hostFailure[];
extern char ignoteMove[];
extern char illegalHint[];
extern char illegalICSMove[];
extern char illegalICSOutput[];
extern char illegalMachineMove[];
extern char illegalMove[];
extern char illegalMoveError[];
extern char incompleteEscapeValue[];
extern char incorrectMoveError[];
extern char indirectionFileError[];
extern char infoSt[];
extern char invalidAlarmTime[];
extern char invalidDataRate[];
extern char invalidFileName[];
extern char invalidIncrement[];
extern char invalidInitialTime[];
extern char invalidMinutes[];
extern char invalidStepRate[];
extern char invalidTimeControl[];
extern char keyboardEOF[];
extern char keyboardError[];
extern char kingSt[];
extern char knightSt[];
extern char lastGame[];
extern char lastPosition[];
extern char lastFileNotAccessible[];
extern char loadGame[];
extern char loadPosition[];
extern char makeMove[];
extern char makeMoveFirst[];
extern char matchEnd[];
extern char minimizeSt[];
extern char misleadingPosition[];
extern char moveNotCurrent[];
extern char nestedError[];
extern char noAnalysis[];
extern char noArgumentValue[];
extern char noBack[];
extern char noBuffer[];
extern char noChessProgram[];
extern char noClipClose[];
extern char noClipMemory[];
extern char noClipText[];
extern char noCmailMessage[];
extern char noColorName[];
extern char noCopyToClip[];
extern char noCPStart[];
extern char noEmptyClip[];
extern char noFEN[];
extern char noFENConversion[];
extern char noFENCopy[];
extern char noFileSize[];
extern char noForward[];
extern char noGame[];
extern char noGameList[];
extern char noGameSelected[];
extern char noHint[];
extern char noICSAnalysis[];
extern char noList[];
extern char noMatch[];
extern char noMemoryLock[];
extern char noMemoryUnlock[];
extern char noMoreFEN[];
extern char noMoreGames[];
extern char noMovesInGame[];
extern char noOpen[];
extern char noOpenClip[];
extern char noOriginalFile[];
extern char noPaste[];
extern char noPendingOffer[];
extern char noPosition[];
extern char noPositionFound[];
extern char noReversion[];
extern char noSeekGame[];
extern char noSeekPosition[];
extern char notBlackTurn[];
extern char notCurrentPosition[];
extern char noteSt[];
extern char noTempFile[];
extern char noTemporaryName[];
extern char noTemporaryOpen[];
extern char noTemporaryRead[];
extern char noTemporaryReopen[];
extern char noTemporaryWrite[];
extern char notExamining[];
extern char noTextMemory[];
extern char noTimeChange[];
extern char notImplemented[];
extern char notOutOfTime[];
extern char notThisVariant[];
extern char notWhiteTurn[];
extern char notWithICS[];
extern char noUnfinishedGames[];
extern char noZippy[];
extern char observingWarn[];
extern char occupiedSquare[];
extern char onlyHeight[];
extern char openClipError[];
extern char optionError[];
extern char outGame[];
extern char outPosition[];
extern char parseError[];
extern char parseMoveError[];
extern char parte1[];
extern char parte2[];
extern char pawn[];
extern char playError[];
extern char playingWarn[];
extern char playsBlack[];
extern char playsWhite[];
extern char portFailure[];
extern char queenSt[];
extern char readError[];
extern char recordedGame[];
extern char readICSError[];
extern char rejectedMove[];
extern char rejectedMoveBy[];
extern char renameError[];
extern char replaceTagError[];
extern char savePosition[];
extern char saveToFile[];
extern char rookSt[];
extern char secondSt[];
extern char selectCP[];
extern char sendToCP[];
extern char sendToSecondCP[];
extern char settings1[];
extern char settings2[];
extern char settings3[];
extern char settings4[];
extern char sizeMissing[];
extern char soundComboError[];
extern char soundError[];
extern char stalemateSt[];
extern char startSecondCP[];
extern char startupFailure[];
extern char tagsSt[];
extern char tempReadError[];
extern char tempWriteError[];
extern char testAnalysis[];
extern char tooManyColors[];
extern char tooManyMoves[];
extern char trainingOff[];
extern char trainingOn[];
extern char trueSt[];
extern char twoHeadersError[];
extern char unableToHelp[];
extern char unknownSt[];
extern char unknownMode[];
extern char unknownVariant[];
extern char unknownWild[];
extern char unrecognizedArgument[];
extern char unrecognizedBoardSize[];
extern char urecognizedBooleanArgument[];
extern char userSt[];
extern char variantICS[];
extern char waitingForFirst[];
extern char waitingForSecond[];
extern char waitOrSelect[];
extern char waitTurn[];
extern char whiteSt[];
extern char whiteN[];
extern char whiteFlagFell[];
extern char whiteMates[];
extern char whiteResigns[];
extern char whiteTime[];
extern char whiteTimeWin[];
extern char whiteToPlay[];
extern char whiteTurn[];
extern char writeCPError[];
extern char writeDisplayError[];
extern char writeError[];
extern char writeICSError[];
extern char yourTurn[];



//


#endif
