X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=backend.c;h=804da7d19d14d219248754064e29c88a7f69f253;hb=d9f4b584106f4d7477158476ff792f6fa0b2630a;hp=d14530f7734ad0a6ef9d6d8f3514ee18cefe9e7f;hpb=3681f490b0a9cdaadd754972147b5140cf2c269b;p=xboard.git

diff --git a/backend.c b/backend.c
index d14530f..804da7d 100644
--- a/backend.c
+++ b/backend.c
@@ -63,6 +63,7 @@ int flock(int f, int code);
 
 #else
 
+#include <sys/file.h>
 #define DoSleep( n ) if( (n) >= 0) sleep(n)
 #define SLASH '/'
 
@@ -233,6 +234,8 @@ void InitDrawingSizes(int x, int y);
 void NextMatchGame P((void));
 int NextTourneyGame P((int nr, int *swap));
 int Pairing P((int nr, int nPlayers, int *w, int *b, int *sync));
+FILE *WriteTourneyFile P((char *results));
+void DisplayTwoMachinesTitle P(());
 
 #ifdef WIN32
        extern void ConsoleCreate();
@@ -394,6 +397,7 @@ PosFlags(index)
   case VariantShatranj:
   case VariantCourier:
   case VariantMakruk:
+  case VariantGrand:
     flags &= ~F_ALL_CASTLE_OK;
     break;
   default:
@@ -417,7 +421,7 @@ char cmailMove[CMAIL_MAX_GAMES][MOVE_LEN], cmailMsg[MSG_SIZ];
 char bookOutput[MSG_SIZ*10], thinkOutput[MSG_SIZ*10], lastHint[MSG_SIZ];
 char thinkOutput1[MSG_SIZ*10];
 
-ChessProgramState first, second;
+ChessProgramState first, second, pairing;
 
 /* premove variables */
 int premoveToX = 0;
@@ -492,7 +496,7 @@ int   nrCastlingRights; // For TwoKings, or to implement castling-unknown status
 int   initialRulePlies, FENrulePlies;
 FILE  *serverMoves = NULL; // next two for broadcasting (/serverMoves option)
 int loadFlag = 0;
-int shuffleOpenings;
+Boolean shuffleOpenings;
 int mute; // mute all sounds
 
 // [HGM] vari: next 12 to save and restore variations
@@ -597,6 +601,13 @@ ChessSquare JanusArray[2][BOARD_FILES] = {
         BlackQueen, BlackBishop, BlackKnight, BlackAngel, BlackRook }
 };
 
+ChessSquare GrandArray[2][BOARD_FILES] = {
+    { EmptySquare, WhiteKnight, WhiteBishop, WhiteQueen, WhiteKing,
+        WhiteMarshall, WhiteAngel, WhiteBishop, WhiteKnight, EmptySquare },
+    { EmptySquare, BlackKnight, BlackBishop, BlackQueen, BlackKing,
+        BlackMarshall, BlackAngel, BlackBishop, BlackKnight, EmptySquare }
+};
+
 #ifdef GOTHIC
 ChessSquare GothicArray[2][BOARD_FILES] = {
     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen, WhiteMarshall,
@@ -796,7 +807,11 @@ InitEngine(ChessProgramState *cps, int n)
 
     /* [HGM] debug */
     cps->debug = FALSE;
+
     cps->supportsNPS = UNKNOWN;
+    cps->memSize = FALSE;
+    cps->maxCores = FALSE;
+    cps->egtFormats[0] = NULLCHAR;
 
     /* [HGM] options */
     cps->optionSettings  = appData.engOptions[n];
@@ -856,6 +871,7 @@ ReplaceEngine(ChessProgramState *cps, int n)
     appData.noChessProgram = FALSE;
     appData.clockMode = TRUE;
     InitEngine(cps, n);
+    UpdateLogos(TRUE);
     if(n) return; // only startup first engine immediately; second can wait
     savCps = cps; // parameter to LoadEngine passed as globals, to allow scheduled calling :-(
     LoadEngine();
@@ -871,7 +887,7 @@ static char resetOptions[] =
 void
 Load(ChessProgramState *cps, int i)
 {
-    char *p, *q, buf[MSG_SIZ], command[MSG_SIZ];
+    char *p, *q, buf[MSG_SIZ], command[MSG_SIZ], buf2[MSG_SIZ];
     if(engineLine[0]) { // an engine was selected from the combo box
 	snprintf(buf, MSG_SIZ, "-fcp %s", engineLine);
 	SwapEngines(i); // kludge to parse -f* / -first* like it is -s* / -second*
@@ -891,6 +907,7 @@ Load(ChessProgramState *cps, int i)
 	appData.directory[i] = strdup(engineName);
 	p[-1] = SLASH;
     } else appData.directory[i] = ".";
+    if(strchr(p, ' ') && !strchr(p, '"')) snprintf(buf2, MSG_SIZ, "\"%s\"", p), p = buf2; // quote if it contains spaces
     if(params[0]) {
 	snprintf(command, MSG_SIZ, "%s %s", p, params);
 	p = command;
@@ -903,15 +920,18 @@ Load(ChessProgramState *cps, int i)
     if(useNick) ASSIGN(appData.pgnName[i], nickName);
     if(addToList) {
 	int len;
+	char quote;
 	q = firstChessProgramNames;
 	if(nickName[0]) snprintf(buf, MSG_SIZ, "\"%s\" -fcp ", nickName); else buf[0] = NULLCHAR;
-	snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), "\"%s\" -fd \"%s\"%s%s%s%s%s%s%s%s\n", p, appData.directory[i], 
+	quote = strchr(p, '"') ? '\'' : '"'; // use single quotes around engine command if it contains double quotes
+	snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), "%c%s%c -fd \"%s\"%s%s%s%s%s%s%s%s\n",
+			quote, p, quote, appData.directory[i], 
 			useNick ? " -fn \"" : "",
 			useNick ? nickName : "",
 			useNick ? "\"" : "",
 			v1 ? " -firstProtocolVersion 1" : "",
 			hasBook ? "" : " -fNoOwnBookUCI",
-			isUCI ? " -fUCI" : "",
+			isUCI ? (isUCI == TRUE ? " -fUCI" : gameInfo.variant == VariantShogi ? " -fUSI" : " -fUCCI") : "",
 			storeVariant ? " -variant " : "",
 			storeVariant ? VariantName(gameInfo.variant) : "");
 	firstChessProgramNames = malloc(len = strlen(q) + strlen(buf) + 1);
@@ -1014,6 +1034,13 @@ InitBackEnd1()
     InitEngine(&second, 1);
     CommonEngineInit();
 
+    pairing.which = "pairing"; // pairing engine
+    pairing.pr = NoProc;
+    pairing.isr = NULL;
+    pairing.program = appData.pairingEngine;
+    pairing.host = "localhost";
+    pairing.dir = ".";
+
     if (appData.icsActive) {
         appData.clockMode = TRUE;  /* changes dynamically in ICS mode */
     } else if (appData.noChessProgram) { // [HGM] st: searchTime mode now also is clockMode
@@ -1094,13 +1121,14 @@ InitBackEnd1()
       case VariantAtomic:     /* should work except for win condition */
       case Variant3Check:     /* should work except for win condition */
       case VariantShatranj:   /* should work except for all win conditions */
-      case VariantMakruk:     /* should work except for daw countdown */
+      case VariantMakruk:     /* should work except for draw countdown */
       case VariantBerolina:   /* might work if TestLegality is off */
       case VariantCapaRandom: /* should work */
       case VariantJanus:      /* should work */
       case VariantSuper:      /* experimental */
       case VariantGreat:      /* experimental, requires legality testing to be off */
       case VariantSChess:     /* S-Chess, should work */
+      case VariantGrand:      /* should work */
       case VariantSpartan:    /* should work */
 	break;
       }
@@ -1364,7 +1392,7 @@ ReserveGame(int gameNr, char resChar)
     safeStrCpy(q, p, strlen(p) + 2);
     if(gameNr >= 0) q[gameNr] = resChar; // replace '*' with result
     if(appData.debugMode) fprintf(debugFP, "pick next game from '%s': %d\n", q, nextGame);
-    if(nextGame <= appData.matchGames && resChar != ' ') { // already reserve next game, if tourney not yet done
+    if(nextGame <= appData.matchGames && resChar != ' ' && !abortMatch) { // reserve next game if tourney not yet done
 	if(q[nextGame] == NULLCHAR) q[nextGame+1] = NULLCHAR; // append one char
 	q[nextGame] = '*';
     }
@@ -1376,7 +1404,7 @@ ReserveGame(int gameNr, char resChar)
     fprintf(tf, "%s\"\n", q); fclose(tf); // update, and flush by closing
     DisplayMessage(buf, "");
     free(p); appData.results = q;
-    if(nextGame <= appData.matchGames && resChar != ' ' &&
+    if(nextGame <= appData.matchGames && resChar != ' ' && !abortMatch &&
        (gameNr < 0 || nextGame / appData.defaultMatchGames != gameNr / appData.defaultMatchGames)) {
 	UnloadEngine(&first);  // next game belongs to other pairing;
 	UnloadEngine(&second); // already unload the engines, so TwoMachinesEvent will load new ones.
@@ -1389,8 +1417,7 @@ MatchEvent(int mode)
 	int dummy;
 	if(matchMode) { // already in match mode: switch it off
 	    abortMatch = TRUE;
-	    appData.matchGames = appData.tourneyFile[0] ? nextGame: matchGame; // kludge to let match terminate after next game.
-	    ModeHighlight(); // kludgey way to remove checkmark...
+	    if(!appData.tourneyFile[0]) appData.matchGames = matchGame; // kludge to let match terminate after next game.
 	    return;
 	}
 //	if(gameMode != BeginningOfGame) {
@@ -1398,14 +1425,29 @@ MatchEvent(int mode)
 //	    return;
 //	}
 	abortMatch = FALSE;
-	appData.matchGames = appData.defaultMatchGames;
+	if(mode == 2) appData.matchGames = appData.defaultMatchGames;
 	/* Set up machine vs. machine match */
 	nextGame = 0;
-	NextTourneyGame(0, &dummy); // sets appData.matchGames if this is tourney, to make sure ReserveGame knows it
+	NextTourneyGame(-1, &dummy); // sets appData.matchGames if this is tourney, to make sure ReserveGame knows it
 	if(appData.tourneyFile[0]) {
 	    ReserveGame(-1, 0);
 	    if(nextGame > appData.matchGames) {
 		char buf[MSG_SIZ];
+		if(strchr(appData.results, '*') == NULL) {
+		    FILE *f;
+		    appData.tourneyCycles++;
+		    if(f = WriteTourneyFile(appData.results)) { // make a tourney file with increased number of cycles
+			fclose(f);
+			NextTourneyGame(-1, &dummy);
+			ReserveGame(-1, 0);
+			if(nextGame <= appData.matchGames) {
+			    DisplayNote(_("You restarted an already completed tourney\nOne more cycle will now be added to it\nGames commence in 10 sec"));
+			    matchMode = mode;
+			    ScheduleDelayedEvent(NextMatchGame, 10000);
+			    return;
+			}
+		    }
+		}
 		snprintf(buf, MSG_SIZ, _("All games in tourney '%s' are already played or playing"), appData.tourneyFile);
 		DisplayError(buf, 0);
 		appData.tourneyFile[0] = 0;
@@ -1419,7 +1461,7 @@ MatchEvent(int mode)
 	}
 	matchMode = mode;
 	matchGame = roundNr = 1;
-	first.matchWins = second.matchWins = 0; // [HGM] match: needed in later matches
+	first.matchWins = second.matchWins = 0; // [HGM] match: needed in later matches
 	NextMatchGame();
 }
 
@@ -1520,6 +1562,8 @@ InitBackEnd3 P((void))
 	    if(f = fopen(appData.tourneyFile, "r")) {
 		ParseArgsFromFile(f); // make sure tourney parmeters re known
 		fclose(f);
+		appData.clockMode = TRUE;
+		SetGNUMode();
 	    } else appData.tourneyFile[0] = NULLCHAR; // for now ignore bad tourney file
 	}
 	MatchEvent(TRUE);
@@ -4607,8 +4651,8 @@ ParseBoard12(string)
 	    safeStrCpy(moveList[moveNum - 1], currentMoveString, sizeof(moveList[moveNum - 1])/sizeof(moveList[moveNum - 1][0]));
 	    strcat(moveList[moveNum - 1], "\n");
 
-            if(gameInfo.holdingsWidth && !appData.disguise && gameInfo.variant != VariantSuper
-                                 && gameInfo.variant != VariantGreat) // inherit info that ICS does not give from previous board
+            if(gameInfo.holdingsWidth && !appData.disguise && gameInfo.variant != VariantSuper && gameInfo.variant != VariantGreat
+                                 && gameInfo.variant != VariantGrand) // inherit info that ICS does not give from previous board
               for(k=0; k<ranks; k++) for(j=BOARD_LEFT; j<BOARD_RGHT; j++) {
                 ChessSquare old, new = boards[moveNum][k][j];
                   if(fromY == DROP_RANK && k==toY && j==toX) continue; // dropped pieces always stand for themselves
@@ -4817,6 +4861,11 @@ SendMoveToProgram(moveNum, cps)
 {
     char buf[MSG_SIZ];
 
+    if(moveList[moveNum][1] == '@' && moveList[moveNum][0] == '@') {
+	// null move in variant where engine does not understand it (for analysis purposes)
+	SendBoard(cps, moveNum + 1); // send position after move in stead.
+	return;
+    }
     if (cps->useUsermove) {
       SendToProgram("usermove ", cps);
     }
@@ -4854,6 +4903,16 @@ SendMoveToProgram(moveNum, cps)
 	  else SendToProgram("O-O-O\n", cps);
 	}
 	else SendToProgram(moveList[moveNum], cps);
+      } else
+      if(BOARD_HEIGHT > 10) { // [HGM] big: convert ranks to double-digit where needed
+	if(moveList[moveNum][1] == '@' && (BOARD_HEIGHT < 16 || moveList[moveNum][0] <= 'Z')) { // drop move
+	  if(moveList[moveNum][0]== '@') snprintf(buf, MSG_SIZ, "@@@@\n"); else
+	  snprintf(buf, MSG_SIZ, "%c@%c%d%s", moveList[moveNum][0],
+					      moveList[moveNum][2], moveList[moveNum][3] - '0', moveList[moveNum]+4);
+	} else
+	  snprintf(buf, MSG_SIZ, "%c%d%c%d%s", moveList[moveNum][0], moveList[moveNum][1] - '0',
+					       moveList[moveNum][2], moveList[moveNum][3] - '0', moveList[moveNum]+4);
+	SendToProgram(buf, cps);
       }
       else SendToProgram(moveList[moveNum], cps);
       /* End of additions by Tord */
@@ -5023,6 +5082,7 @@ CoordsToComputerAlgebraic(rf, ff, rt, ft, promoChar, move)
      char move[7];
 {
     if (rf == DROP_RANK) {
+      if(ff == EmptySquare) sprintf(move, "@@@@\n"); else // [HGM] pass
       sprintf(move, "%c@%c%c\n",
                 ToUpper(PieceToChar((ChessSquare) ff)), AAA + ft, ONE + rt);
     } else {
@@ -5242,6 +5302,7 @@ ParseOneMove(move, moveNum, moveType, fromX, fromY, toX, toY, promoChar)
 }
 
 Boolean pushed = FALSE;
+char *lastParseAttempt;
 
 void
 ParsePV(char *pv, Boolean storeComments, Boolean atEnd)
@@ -5259,6 +5320,7 @@ ParsePV(char *pv, Boolean storeComments, Boolean atEnd)
   do {
     while(*pv == ' ' || *pv == '\n' || *pv == '\t') pv++; // must still read away whitespace
     if(nr == 0 && !storeComments && *pv == '(') pv++; // first (ponder) move can be in parentheses
+    lastParseAttempt = pv;
     valid = ParseOneMove(pv, endPV, &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
 if(appData.debugMode){
 fprintf(debugFP,"parsePV: %d %c%c%c%c yy='%s'\nPV = '%s'\n", valid, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, yy_textstr, pv);
@@ -5300,6 +5362,7 @@ fprintf(debugFP,"parsePV: %d %c%c%c%c yy='%s'\nPV = '%s'\n", valid, fromX+AAA, f
 			     fromY, fromX, toY, toX, promoChar,
 			     parseList[endPV - 1]);
   } while(valid);
+  if(atEnd == 2) return; // used hidden, for PV conversion
   currentMove = (atEnd || endPV == forwardMostMove) ? endPV : forwardMostMove + 1;
   if(currentMove == forwardMostMove) ClearPremoveHighlights(); else
   SetPremoveHighlights(moveList[currentMove-1][0]-AAA, moveList[currentMove-1][1]-ONE,
@@ -5347,6 +5410,25 @@ LoadMultiPV(int x, int y, char *buf, int index, int *start, int *end)
 	return TRUE;
 }
 
+char *
+PvToSAN(char *pv)
+{
+	static char buf[10*MSG_SIZ];
+	int i, k=0, savedEnd=endPV;
+	*buf = NULLCHAR;
+	if(forwardMostMove < endPV) PushInner(forwardMostMove, endPV);
+	ParsePV(pv, FALSE, 2); // this appends PV to game, suppressing any display of it
+	for(i = forwardMostMove; i<endPV; i++){
+	    if(i&1) snprintf(buf+k, 10*MSG_SIZ-k, "%s ", parseList[i]);
+	    else    snprintf(buf+k, 10*MSG_SIZ-k, "%d. %s ", i/2 + 1, parseList[i]);
+	    k += strlen(buf+k);
+	}
+	snprintf(buf+k, 10*MSG_SIZ-k, "%s", lastParseAttempt); // if we ran into stuff that could not be parsed, print it verbatim
+	if(forwardMostMove < savedEnd) PopInner(0);
+	endPV = savedEnd;
+	return buf;
+}
+
 Boolean
 LoadPV(int x, int y)
 { // called on right mouse click to load PV
@@ -5690,6 +5772,14 @@ InitPosition(redraw)
     case VariantTwoKings:
       pieces = twoKingsArray;
       break;
+    case VariantGrand:
+      pieces = GrandArray;
+      nrCastlingRights = 0;
+      SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
+      gameInfo.boardWidth = 10;
+      gameInfo.boardHeight = 10;
+      gameInfo.holdingsSize = 7;
+      break;
     case VariantCapaRandom:
       shuffleOpenings = TRUE;
     case VariantCapablanca:
@@ -5806,7 +5896,7 @@ InitPosition(redraw)
 
     pawnRow = gameInfo.boardHeight - 7; /* seems to work in all common variants */
     if(pawnRow < 1) pawnRow = 1;
-    if(gameInfo.variant == VariantMakruk) pawnRow = 2;
+    if(gameInfo.variant == VariantMakruk || gameInfo.variant == VariantGrand) pawnRow = 2;
 
     /* User pieceToChar list overrules defaults */
     if(appData.pieceToCharTable != NULL)
@@ -5820,7 +5910,7 @@ InitPosition(redraw)
             initialPosition[i][j] = s;
 
         if(j < BOARD_LEFT || j >= BOARD_RGHT || overrule) continue;
-        initialPosition[0][j] = pieces[0][j-gameInfo.holdingsWidth];
+        initialPosition[gameInfo.variant == VariantGrand][j] = pieces[0][j-gameInfo.holdingsWidth];
         initialPosition[pawnRow][j] = WhitePawn;
         initialPosition[BOARD_HEIGHT-pawnRow-1][j] = gameInfo.variant == VariantSpartan ? BlackLance : BlackPawn;
         if(gameInfo.variant == VariantXiangqi) {
@@ -5833,7 +5923,13 @@ InitPosition(redraw)
                 }
             }
         }
-        initialPosition[BOARD_HEIGHT-1][j] =  pieces[1][j-gameInfo.holdingsWidth];
+        if(gameInfo.variant == VariantGrand) {
+            if(j==BOARD_LEFT || j>=BOARD_RGHT-1) {
+               initialPosition[0][j] = WhiteRook;
+               initialPosition[BOARD_HEIGHT-1][j] = BlackRook;
+            }
+        }
+        initialPosition[BOARD_HEIGHT-1-(gameInfo.variant == VariantGrand)][j] =  pieces[1][j-gameInfo.holdingsWidth];
     }
     if( (gameInfo.variant == VariantShogi) && !overrule ) {
 
@@ -5992,7 +6088,7 @@ DefaultPromoChoice(int white)
 static int autoQueen; // [HGM] oneclick
 
 int
-HasPromotionChoice(int fromX, int fromY, int toX, int toY, char *promoChoice)
+HasPromotionChoice(int fromX, int fromY, int toX, int toY, char *promoChoice, int sweepSelect)
 {
     /* [HGM] rewritten IsPromotion to only flag promotions that offer a choice */
     /* [HGM] add Shogi promotions */
@@ -6012,7 +6108,7 @@ HasPromotionChoice(int fromX, int fromY, int toX, int toY, char *promoChoice)
     if(gameInfo.variant == VariantShogi) {
         promotionZoneSize = BOARD_HEIGHT/3;
         highestPromotingPiece = (int)WhiteFerz;
-    } else if(gameInfo.variant == VariantMakruk) {
+    } else if(gameInfo.variant == VariantMakruk || gameInfo.variant == VariantGrand) {
         promotionZoneSize = 3;
     }
 
@@ -6074,9 +6170,9 @@ HasPromotionChoice(int fromX, int fromY, int toX, int toY, char *promoChoice)
     }
     // give caller the default choice even if we will not make it
     *promoChoice = ToLower(PieceToChar(defaultPromoChoice));
-    if(gameInfo.variant == VariantShogi) *promoChoice = '+';
-    if(appData.sweepSelect && gameInfo.variant != VariantGreat
-			   && gameInfo.variant != VariantShogi
+    if(gameInfo.variant == VariantShogi) *promoChoice = (defaultPromoChoice == piece ? '=' : '+');
+    if(        sweepSelect && gameInfo.variant != VariantGreat
+			   && gameInfo.variant != VariantGrand
 			   && gameInfo.variant != VariantSuper) return FALSE;
     if(autoQueen) return FALSE; // predetermined
 
@@ -6135,7 +6231,6 @@ OKToStartUserMove(x, y)
       (int)from_piece < (int)BlackPawn; /* [HGM] can be > King! */
 
     switch (gameMode) {
-      case PlayFromGameFile:
       case AnalyzeFile:
       case TwoMachinesPlay:
       case EndOfGame:
@@ -6163,6 +6258,8 @@ OKToStartUserMove(x, y)
 	}
 	break;
 
+      case PlayFromGameFile:
+	    if(!shiftKey || !appData.variations) return FALSE; // [HGM] allow starting variation in this mode
       case EditGame:
 	if (!white_piece && WhiteOnMove(currentMove)) {
 	    DisplayMoveError(_("It is White's turn"));
@@ -6206,6 +6303,7 @@ OKToStartUserMove(x, y)
     }
     if (currentMove != forwardMostMove && gameMode != AnalyzeMode
 	&& gameMode != EditGame // [HGM] vari: treat as AnalyzeMode
+	&& gameMode != PlayFromGameFile // [HGM] as EditGame, with protected main line
 	&& gameMode != AnalyzeFile && gameMode != Training) {
 	DisplayMoveError(_("Displayed position is not current"));
 	return FALSE;
@@ -6216,7 +6314,7 @@ OKToStartUserMove(x, y)
 Boolean
 OnlyMove(int *x, int *y, Boolean captures) {
     DisambiguateClosure cl;
-    if (appData.zippyPlay) return FALSE;
+    if (appData.zippyPlay || !appData.testLegality) return FALSE;
     switch(gameMode) {
       case MachinePlaysBlack:
       case IcsPlayingWhite:
@@ -6297,7 +6395,6 @@ UserMoveEvent(fromX, fromY, toX, toY, promoChar)
        */
 
     switch (gameMode) {
-      case PlayFromGameFile:
       case AnalyzeFile:
       case TwoMachinesPlay:
       case EndOfGame:
@@ -6323,6 +6420,8 @@ UserMoveEvent(fromX, fromY, toX, toY, promoChar)
 	}
 	break;
 
+      case PlayFromGameFile:
+	    if(!shiftKey ||!appData.variations) return; // [HGM] only variations
       case EditGame:
       case IcsExamining:
       case BeginningOfGame:
@@ -6438,6 +6537,9 @@ UserMoveEvent(fromX, fromY, toX, toY, promoChar)
     /* [HGM] always test for legality, to get promotion info */
     moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
                                          fromY, fromX, toY, toX, promoChar);
+
+    if(fromY == DROP_RANK && fromX == EmptySquare && (gameMode == AnalyzeMode || gameMode == EditGame)) moveType = NormalMove;
+
     /* [HGM] but possibly ignore an IllegalMove result */
     if (appData.testLegality) {
 	if (moveType == IllegalMove || moveType == ImpossibleMove) {
@@ -6458,8 +6560,8 @@ FinishMove(moveType, fromX, fromY, toX, toY, promoChar)
 {
     char *bookHit = 0;
 
-    if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) && promoChar != NULLCHAR) {
-	// [HGM] superchess: suppress promotions to non-available piece
+    if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) && promoChar != NULLCHAR) {
+	// [HGM] superchess: suppress promotions to non-available piece (but P always allowed)
 	int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
 	if(WhiteOnMove(currentMove)) {
 	    if(!boards[currentMove][k][BOARD_WIDTH-2]) return 0;
@@ -6514,7 +6616,7 @@ FinishMove(moveType, fromX, fromY, toX, toY, promoChar)
 
   /* Ok, now we know that the move is good, so we can kill
      the previous line in Analysis Mode */
-  if ((gameMode == AnalyzeMode || gameMode == EditGame)
+  if ((gameMode == AnalyzeMode || gameMode == EditGame || gameMode == PlayFromGameFile && appData.variations && shiftKey)
 				&& currentMove < forwardMostMove) {
     if(appData.variations && shiftKey) PushTail(currentMove, forwardMostMove); // [HGM] vari: save tail of game
     else forwardMostMove = currentMove;
@@ -6579,6 +6681,9 @@ FinishMove(moveType, fromX, fromY, toX, toY, promoChar)
 	 // [HGM] book: if program might be playing, let it use book
 	bookHit = SendMoveToBookUser(forwardMostMove-1, &first, FALSE);
 	first.maybeThinking = TRUE;
+    } else if(fromY == DROP_RANK && fromX == EmptySquare) {
+	if(!first.useSetboard) SendToProgram("undo\n", &first); // kludge to change stm in engines that do not support setboard
+	SendBoard(&first, currentMove+1);
     } else SendMoveToProgram(forwardMostMove-1, &first);
     if (currentMove == cmailOldMove + 1) {
       cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
@@ -6656,13 +6761,13 @@ void
 MarkTargetSquares(int clear)
 {
   int x, y;
-  if(!appData.markers || !appData.highlightDragging ||
+  if(!appData.markers || !appData.highlightDragging || appData.icsActive && gameInfo.variant < VariantShogi ||
      !appData.testLegality || gameMode == EditPosition) return;
   if(clear) {
     for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) marker[y][x] = 0;
   } else {
     int capt = 0;
-    GenLegal(boards[currentMove], PosFlags(currentMove), Mark, (void*) marker);
+    GenLegal(boards[currentMove], PosFlags(currentMove), Mark, (void*) marker, EmptySquare);
     if(PosFlags(0) & F_MANDATORY_CAPTURE) {
       for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) if(marker[y][x]>1) capt++;
       if(capt)
@@ -6717,7 +6822,6 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
     }
 
     if (clickType == Press) ErrorPopDown();
-    MarkTargetSquares(1);
 
     x = EventToSquare(xPix, BOARD_WIDTH);
     y = EventToSquare(yPix, BOARD_HEIGHT);
@@ -6732,7 +6836,7 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 	defaultPromoChoice = promoSweep;
 	promoSweep = EmptySquare;   // terminate sweep
 	promoDefaultAltered = TRUE;
-	if(!selectFlag) x = fromX, y = fromY; // and fake up-click on same square if we were still selecting
+	if(!selectFlag && (x != toX || y != toY)) x = fromX, y = fromY; // and fake up-click on same square if we were still selecting
     }
 
     if(promotionChoice) { // we are waiting for a click to indicate promotion piece
@@ -6741,13 +6845,14 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 	if(appData.debugMode) fprintf(debugFP, "promotion click, x=%d, y=%d\n", x, y);
 	if(gameInfo.holdingsWidth &&
 		(WhiteOnMove(currentMove)
-			? x == BOARD_WIDTH-1 && y < gameInfo.holdingsSize && y > 0
-			: x == 0 && y >= BOARD_HEIGHT - gameInfo.holdingsSize && y < BOARD_HEIGHT-1) ) {
+			? x == BOARD_WIDTH-1 && y < gameInfo.holdingsSize && y >= 0
+			: x == 0 && y >= BOARD_HEIGHT - gameInfo.holdingsSize && y < BOARD_HEIGHT) ) {
 	    // click in right holdings, for determining promotion piece
 	    ChessSquare p = boards[currentMove][y][x];
 	    if(appData.debugMode) fprintf(debugFP, "square contains %d\n", (int)p);
-	    if(p != EmptySquare) {
-		FinishMove(NormalMove, fromX, fromY, toX, toY, ToLower(PieceToChar(p)));
+	    if(p == WhitePawn || p == BlackPawn) p = EmptySquare; // [HGM] Pawns could be valid as deferral
+	    if(p != EmptySquare || gameInfo.variant == VariantGrand && toY != 0 && toY != BOARD_HEIGHT-1) { // [HGM] grand: empty square means defer
+		FinishMove(NormalMove, fromX, fromY, toX, toY, p==EmptySquare ? NULLCHAR : ToLower(PieceToChar(p)));
 		fromX = fromY = -1;
 		return;
 	    }
@@ -6784,7 +6889,7 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 	}
 	return;
       }
-      fromX = x; fromY = y;
+      fromX = x; fromY = y; toX = toY = -1;
       if(!appData.oneClick || !OnlyMove(&x, &y, FALSE) ||
 	 // even if only move, we treat as normal when this would trigger a promotion popup, to allow sweep selection
 	 appData.sweepSelect && CanPromote(boards[currentMove][fromY][fromX], fromY) && originalY != y) {
@@ -6792,7 +6897,7 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 	    if (OKToStartUserMove(fromX, fromY)) {
 		second = 0;
 		MarkTargetSquares(0);
-		DragPieceBegin(xPix, yPix); dragging = 1;
+		DragPieceBegin(xPix, yPix, FALSE); dragging = 1;
 		if(appData.sweepSelect && CanPromote(piece = boards[currentMove][fromY][fromX], fromY)) {
 		    promoSweep = defaultPromoChoice;
 		    selectFlag = 0; lastX = xPix; lastY = yPix;
@@ -6831,6 +6936,7 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 	    /* Clicked again on same color piece -- changed his mind */
 	    second = (x == fromX && y == fromY);
 	    promoDefaultAltered = FALSE;
+	    MarkTargetSquares(1);
 	   if(!second || appData.oneClick && !OnlyMove(&x, &y, TRUE)) {
 	    if (appData.highlightDragging) {
 		SetHighlights(x, y, -1, -1);
@@ -6846,7 +6952,7 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 		fromX = x;
 		fromY = y; dragging = 1;
 		MarkTargetSquares(0);
-		DragPieceBegin(xPix, yPix);
+		DragPieceBegin(xPix, yPix, FALSE);
 		if(appData.sweepSelect && CanPromote(piece = boards[currentMove][y][x], y)) {
 		    promoSweep = defaultPromoChoice;
 		    selectFlag = 0; lastX = xPix; lastY = yPix;
@@ -6897,13 +7003,25 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
     toX = x;
     toY = y;
     saveAnimate = appData.animate;
+    MarkTargetSquares(1);
     if (clickType == Press) {
 	if(gameMode == EditPosition && boards[currentMove][fromY][fromX] == EmptySquare) {
 	    // must be Edit Position mode with empty-square selected
-	    fromX = x; fromY = y; DragPieceBegin(xPix, yPix); dragging = 1; // consider this a new attempt to drag
+	    fromX = x; fromY = y; DragPieceBegin(xPix, yPix, FALSE); dragging = 1; // consider this a new attempt to drag
 	    if(x >= BOARD_LEFT && x < BOARD_RGHT) clearFlag = 1; // and defer click-click move of empty-square to up-click
 	    return;
 	}
+	if(appData.sweepSelect && HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice, FALSE)) {
+	    ChessSquare piece = boards[currentMove][fromY][fromX];
+	    DragPieceBegin(xPix, yPix, TRUE); dragging = 1;
+	    promoSweep = defaultPromoChoice;
+	    if(PieceToChar(PROMOTED piece) == '+') promoSweep = PROMOTED piece;
+	    selectFlag = 0; lastX = xPix; lastY = yPix;
+	    Sweep(0); // Pawn that is going to promote: preview promotion piece
+	    DisplayMessage("", _("Pull pawn backwards to under-promote"));
+	    DrawPosition(FALSE, boards[currentMove]);
+	    return;
+	}
 	/* Finish clickclick move */
 	if (appData.animate || appData.highlightLastMove) {
 	    SetHighlights(fromX, fromY, toX, toY);
@@ -6954,9 +7072,9 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 
     if(gatingPiece != EmptySquare) promoChoice = ToLower(PieceToChar(gatingPiece));
 
-    if (HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice)) {
+    if (HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice, appData.sweepSelect)) {
 	SetHighlights(fromX, fromY, toX, toY);
-	if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
+	if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) {
 	    // [HGM] super: promotion to captured piece selected from holdings
 	    ChessSquare p = boards[currentMove][fromY][fromX], q = boards[currentMove][toY][toX];
 	    promotionChoice = TRUE;
@@ -7026,16 +7144,16 @@ int RightClick(ClickType action, int x, int y, int *fromX, int *fromY)
     if (action != Press) return -2; // return code to be ignored
     switch (gameMode) {
       case IcsExamining:
-	if(xSqr < BOARD_LEFT || xSqr >= BOARD_RGHT) return -1;
+	if(xSqr < BOARD_LEFT || xSqr >= BOARD_RGHT) return -1;
       case EditPosition:
-	if (xSqr == BOARD_LEFT-1 || xSqr == BOARD_RGHT) return -1;
+	if (xSqr == BOARD_LEFT-1 || xSqr == BOARD_RGHT) return -1;
 	if (xSqr < 0 || ySqr < 0) return -1;
 	if(appData.pieceMenu) { whichMenu = 0; break; } // edit-position menu
 	pieceSweep = shiftKey ? BlackPawn : WhitePawn;  // [HGM] sweep: prepare selecting piece by mouse sweep
 	toX = xSqr; toY = ySqr; lastX = x, lastY = y;
 	if(flipView) toX = BOARD_WIDTH - 1 - toX; else toY = BOARD_HEIGHT - 1 - toY;
 	NextPiece(0);
-	return -2;
+	return 2; // grab
       case IcsObserving:
 	if(!appData.icsEngineAnalyze) return -1;
       case IcsPlayingWhite:
@@ -7103,6 +7221,15 @@ void SendProgramStatsToFrontend( ChessProgramState * cps, ChessProgramStats * cp
     SetProgramStats( &stats );
 }
 
+void
+ClearEngineOutputPane(int which)
+{
+    static FrontEndProgramStats dummyStats;
+    dummyStats.which = which;
+    dummyStats.pv = "#";
+    SetProgramStats( &dummyStats );
+}
+
 #define MAXPLAYERS 500
 
 char *
@@ -7112,6 +7239,8 @@ TourneyStandings(int display)
     int score[MAXPLAYERS], ranking[MAXPLAYERS], points[MAXPLAYERS], games[MAXPLAYERS];
     char result, *p, *names[MAXPLAYERS];
 
+    if(appData.tourneyType < 0 && !strchr(appData.results, '*'))
+	return strdup(_("Swiss tourney finished")); // standings of Swiss yet TODO
     names[0] = p = strdup(appData.participants);
     while(p = strchr(p, '\n')) *p++ = NULLCHAR, names[++nPlayers] = p; // count participants
 
@@ -7245,6 +7374,28 @@ MatingPotential(int pCnt[], int side, int nMine, int nHis, int stale, int bisCol
 }
 
 int
+CompareWithRights(Board b1, Board b2)
+{
+    int rights = 0;
+    if(!CompareBoards(b1, b2)) return FALSE;
+    if(b1[EP_STATUS] != b2[EP_STATUS]) return FALSE;
+    /* compare castling rights */
+    if( b1[CASTLING][2] != b2[CASTLING][2] && (b2[CASTLING][0] != NoRights || b2[CASTLING][1] != NoRights) )
+           rights++; /* King lost rights, while rook still had them */
+    if( b1[CASTLING][2] != NoRights ) { /* king has rights */
+        if( b1[CASTLING][0] != b2[CASTLING][0] || b1[CASTLING][1] != b2[CASTLING][1] )
+           rights++; /* but at least one rook lost them */
+    }
+    if( b1[CASTLING][5] != b1[CASTLING][5] && (b2[CASTLING][3] != NoRights || b2[CASTLING][4] != NoRights) )
+           rights++;
+    if( b1[CASTLING][5] != NoRights ) {
+        if( b1[CASTLING][3] != b2[CASTLING][3] || b1[CASTLING][4] != b2[CASTLING][4] )
+           rights++;
+    }
+    return rights == 0;
+}
+
+int
 Adjudicate(ChessProgramState *cps)
 {	// [HGM] some adjudications useful with buggy engines
 	// [HGM] adjudicate: made into separate routine, which now can be called after every move
@@ -7570,8 +7721,23 @@ char *SendMoveToBookUser(int moveNr, ChessProgramState *cps, int initial)
     if(bookHit) {
 	// after a book hit we never send 'go', and the code after the call to this routine
 	// has '&& !bookHit' added to suppress potential sending there (based on 'firstMove').
-	char buf[MSG_SIZ];
-	snprintf(buf, MSG_SIZ, "%s%s\n", (cps->useUsermove ? "usermove " : ""), bookHit); // force book move into program supposed to play it
+	char buf[MSG_SIZ], *move = bookHit;
+	if(cps->useSAN) {
+	    int fromX, fromY, toX, toY;
+	    char promoChar;
+	    ChessMove moveType;
+	    move = buf + 30;
+	    if (ParseOneMove(bookHit, forwardMostMove, &moveType,
+				 &fromX, &fromY, &toX, &toY, &promoChar)) {
+		(void) CoordsToAlgebraic(boards[forwardMostMove],
+				    PosFlags(forwardMostMove),
+				    fromY, fromX, toY, toX, promoChar, move);
+	    } else {
+		if(appData.debugMode) fprintf(debugFP, "Book move could not be parsed\n");
+		bookHit = NULL;
+	    }
+	}
+	snprintf(buf, MSG_SIZ, "%s%s\n", (cps->useUsermove ? "usermove " : ""), move); // force book move into program supposed to play it
 	SendToProgram(buf, cps);
 	if(!initial) firstMove = FALSE; // normally we would clear the firstMove condition after return & sending 'go'
     } else if(initial) { // 'go' was needed irrespective of firstMove, and it has to be done in this routine
@@ -7595,6 +7761,8 @@ void DeferredBookMove(void)
 	HandleMachineMove(savedMessage, savedState);
 }
 
+static int savedWhitePlayer, savedBlackPlayer, pairingReceived;
+
 void
 HandleMachineMove(message, cps)
      char *message;
@@ -7605,10 +7773,21 @@ HandleMachineMove(message, cps)
     int fromX, fromY, toX, toY;
     ChessMove moveType;
     char promoChar;
-    char *p;
+    char *p, *pv=buf1;
     int machineWhite;
     char *bookHit;
 
+    if(cps == &pairing && sscanf(message, "%d-%d", &savedWhitePlayer, &savedBlackPlayer) == 2) {
+	// [HGM] pairing: Mega-hack! Pairing engine also uses this routine (so it could give other WB commands).
+	if(savedWhitePlayer == 0 || savedBlackPlayer == 0) {
+	    DisplayError(_("Invalid pairing from pairing engine"), 0);
+	    return;
+	}
+	pairingReceived = 1;
+	NextMatchGame();
+	return; // Skim the pairing messages here.
+    }
+
     cps->userError = 0;
 
 FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book hit
@@ -7965,6 +8144,7 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
     if (!strncmp(message, "telluser ", 9)) {
 	if(message[9] == '\\' && message[10] == '\\')
 	    EscapeExpand(message+9, message+11); // [HGM] esc: allow escape sequences in popup box
+	PlayTellSound();
 	DisplayNote(message + 9);
 	return;
     }
@@ -7972,6 +8152,7 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
 	cps->userError = 1;
 	if(message[14] == '\\' && message[15] == '\\')
 	    EscapeExpand(message+14, message+16); // [HGM] esc: allow escape sequences in popup box
+	PlayTellSound();
 	DisplayError(message + 14, 0);
 	return;
     }
@@ -8449,6 +8630,7 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
                     curscore = -curscore;
                 }
 
+		if(appData.pvSAN[cps==&second]) pv = PvToSAN(buf1);
 
 		tempStats.depth = plylev;
 		tempStats.nodes = nodes;
@@ -8470,15 +8652,15 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
 		}
 
 		/* Buffer overflow protection */
-		if (buf1[0] != NULLCHAR) {
-		    if (strlen(buf1) >= sizeof(tempStats.movelist)
+		if (pv[0] != NULLCHAR) {
+		    if (strlen(pv) >= sizeof(tempStats.movelist)
 			&& appData.debugMode) {
 			fprintf(debugFP,
 				"PV is too long; using the first %u bytes.\n",
 				(unsigned) sizeof(tempStats.movelist) - 1);
 		    }
 
-                    safeStrCpy( tempStats.movelist, buf1, sizeof(tempStats.movelist)/sizeof(tempStats.movelist[0]) );
+                    safeStrCpy( tempStats.movelist, pv, sizeof(tempStats.movelist)/sizeof(tempStats.movelist[0]) );
 		} else {
 		    sprintf(tempStats.movelist, " no PV\n");
 		}
@@ -8515,14 +8697,14 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
                 if( buf1[0] != NULLCHAR ) {
                     unsigned max_len = sizeof(thinkOutput) - strlen(thinkOutput) - 1;
 
-                    if( strlen(buf1) > max_len ) {
+                    if( strlen(pv) > max_len ) {
 			if( appData.debugMode) {
 			    fprintf(debugFP,"PV is too long for thinkOutput, truncating.\n");
                         }
-                        buf1[max_len+1] = '\0';
+                        pv[max_len+1] = '\0';
                     }
 
-                    strcat( thinkOutput, buf1 );
+                    strcat( thinkOutput, pv);
                 }
 
                 if (currentMove == forwardMostMove || gameMode == AnalyzeMode
@@ -8853,7 +9035,7 @@ ApplyMove(fromX, fromY, toX, toY, promoChar, board)
      Board board;
 {
   ChessSquare captured = board[toY][toX], piece, king; int p, oldEP = EP_NONE, berolina = 0;
-  int promoRank = gameInfo.variant == VariantMakruk ? 3 : 1;
+  int promoRank = gameInfo.variant == VariantMakruk || gameInfo.variant == VariantGrand ? 3 : 1;
 
     /* [HGM] compute & store e.p. status and castling rights for new position */
     /* we can always do that 'in place', now pointers to these rights are passed to ApplyMove */
@@ -8862,15 +9044,19 @@ ApplyMove(fromX, fromY, toX, toY, promoChar, board)
       oldEP = (signed char)board[EP_STATUS];
       board[EP_STATUS] = EP_NONE;
 
-      if( board[toY][toX] != EmptySquare )
-           board[EP_STATUS] = EP_CAPTURE;
-
   if (fromY == DROP_RANK) {
 	/* must be first */
+        if(fromX == EmptySquare) { // [HGM] pass: empty drop encodes null move; nothing to change.
+	    board[EP_STATUS] = EP_CAPTURE; // null move considered irreversible
+	    return;
+	}
         piece = board[toY][toX] = (ChessSquare) fromX;
   } else {
       int i;
 
+      if( board[toY][toX] != EmptySquare )
+           board[EP_STATUS] = EP_CAPTURE;
+
       if( board[fromY][fromX] == WhiteLance || board[fromY][fromX] == BlackLance ) {
            if( gameInfo.variant != VariantSuper && gameInfo.variant != VariantShogi )
                board[EP_STATUS] = EP_PAWN_MOVE; // Lance is Pawn-like in most variants
@@ -8951,18 +9137,15 @@ ApplyMove(fromX, fromY, toX, toY, promoChar, board)
         board[fromY][BOARD_LEFT] = EmptySquare;
     } else if ((board[fromY][fromX] == WhitePawn && gameInfo.variant != VariantXiangqi ||
                 board[fromY][fromX] == WhiteLance && gameInfo.variant != VariantSuper && gameInfo.variant != VariantShogi)
-               && toY >= BOARD_HEIGHT-promoRank
+               && toY >= BOARD_HEIGHT-promoRank && promoChar // defaulting to Q is done elsewhere
                ) {
 	/* white pawn promotion */
         board[toY][toX] = CharToPiece(ToUpper(promoChar));
-        if (board[toY][toX] == EmptySquare) {
-            board[toY][toX] = WhiteQueen;
-	}
         if(gameInfo.variant==VariantBughouse ||
            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
 	board[fromY][fromX] = EmptySquare;
-    } else if ((fromY == BOARD_HEIGHT-4)
+    } else if ((fromY >= BOARD_HEIGHT>>1)
 	       && (toX != fromX)
                && gameInfo.variant != VariantXiangqi
                && gameInfo.variant != VariantBerolina
@@ -9015,18 +9198,15 @@ ApplyMove(fromX, fromY, toX, toY, promoChar, board)
 	board[toY][2] = BlackRook;
     } else if ((board[fromY][fromX] == BlackPawn && gameInfo.variant != VariantXiangqi ||
                 board[fromY][fromX] == BlackLance && gameInfo.variant != VariantSuper && gameInfo.variant != VariantShogi)
-	       && toY < promoRank
+	       && toY < promoRank && promoChar
                ) {
 	/* black pawn promotion */
 	board[toY][toX] = CharToPiece(ToLower(promoChar));
-	if (board[toY][toX] == EmptySquare) {
-	    board[toY][toX] = BlackQueen;
-	}
         if(gameInfo.variant==VariantBughouse ||
            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
 	board[fromY][fromX] = EmptySquare;
-    } else if ((fromY == 3)
+    } else if ((fromY < BOARD_HEIGHT>>1)
 	       && (toX != fromX)
                && gameInfo.variant != VariantXiangqi
                && gameInfo.variant != VariantBerolina
@@ -9087,7 +9267,7 @@ ApplyMove(fromX, fromY, toX, toY, promoChar, board)
       if (captured != EmptySquare && gameInfo.holdingsSize > 0
           && gameInfo.variant != VariantBughouse && gameInfo.variant != VariantSChess        ) {
         /* [HGM] holdings: Add to holdings, if holdings exist */
-	if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
+	if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) {
 		// [HGM] superchess: suppress flipping color of captured pieces by reverse pre-flip
 		captured = (int) captured >= (int) BlackPawn ? BLACK_TO_WHITE captured : WHITE_TO_BLACK captured;
 	}
@@ -9138,8 +9318,8 @@ ApplyMove(fromX, fromY, toX, toY, promoChar, board)
     } else if(!appData.testLegality && promoChar != NULLCHAR && promoChar != '=') { // without legality testing, unconditionally believe promoChar
         board[toY][toX] = CharToPiece(piece < BlackPawn ? ToUpper(promoChar) : ToLower(promoChar));
     }
-    if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) 
-		&& promoChar != NULLCHAR && gameInfo.holdingsSize) { 
+    if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand)
+		&& promoChar != NULLCHAR && gameInfo.holdingsSize) {
 	// [HGM] superchess: take promotion piece out of holdings
 	int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
 	if((int)piece < (int)BlackPawn) { // determine stm from piece color
@@ -9367,6 +9547,8 @@ InitChessProgram(cps, setup)
            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
       if( gameInfo.variant == VariantSChess )
            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 7;
+      if( gameInfo.variant == VariantGrand )
+           overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 10 || gameInfo.holdingsSize != 7;
 
       if(overruled) {
 	snprintf(b, MSG_SIZ, "%dx%d+%d_%s", gameInfo.boardWidth, gameInfo.boardHeight,
@@ -9428,6 +9610,7 @@ InitChessProgram(cps, setup)
       SendToProgram(buf, cps);
     }
     cps->initDone = TRUE;
+    ClearEngineOutputPane(cps == &second);
 }
 
 
@@ -9458,9 +9641,14 @@ StartChessProgram(cps)
 
     if (err != 0) {
       snprintf(buf, MSG_SIZ, _("Startup failure on '%s'"), cps->program);
-	DisplayFatalError(buf, err, 1);
-	cps->pr = NoProc;
-	cps->isr = NULL;
+	DisplayError(buf, err); // [HGM] bit of a rough kludge: ignore failure, (which XBoard would do anyway), and let I/O discover it
+	if(cps != &first) return;
+	appData.noChessProgram = TRUE;
+	ThawUI();
+	SetNCPMode();
+//	DisplayFatalError(buf, err, 1);
+//	cps->pr = NoProc;
+//	cps->isr = NULL;
 	return;
     }
 
@@ -9494,39 +9682,95 @@ TwoMachinesEventIfReady P((void))
   TwoMachinesEvent();
 }
 
+char *
+MakeName(char *template)
+{
+    time_t clock;
+    struct tm *tm;
+    static char buf[MSG_SIZ];
+    char *p = buf;
+    int i;
+
+    clock = time((time_t *)NULL);
+    tm = localtime(&clock);
+
+    while(*p++ = *template++) if(p[-1] == '%') {
+	switch(*template++) {
+	  case 0:   *p = 0; return buf;
+	  case 'Y': i = tm->tm_year+1900; break;
+	  case 'y': i = tm->tm_year-100; break;
+	  case 'M': i = tm->tm_mon+1; break;
+	  case 'd': i = tm->tm_mday; break;
+	  case 'h': i = tm->tm_hour; break;
+	  case 'm': i = tm->tm_min; break;
+	  case 's': i = tm->tm_sec; break;
+	  default:  i = 0;
+	}
+	snprintf(p-1, MSG_SIZ-10 - (p - buf), "%02d", i); p += strlen(p);
+    }
+    return buf;
+}
+
+int
+CountPlayers(char *p)
+{
+    int n = 0;
+    while(p = strchr(p, '\n')) p++, n++; // count participants
+    return n;
+}
+
+FILE *
+WriteTourneyFile(char *results)
+{   // write tournament parameters on tourneyFile; on success return the stream pointer for closing
+    FILE *f = fopen(appData.tourneyFile, "w");
+    if(f == NULL) DisplayError(_("Could not write on tourney file"), 0); else {
+	// create a file with tournament description
+	fprintf(f, "-participants {%s}\n", appData.participants);
+	fprintf(f, "-tourneyType %d\n", appData.tourneyType);
+	fprintf(f, "-tourneyCycles %d\n", appData.tourneyCycles);
+	fprintf(f, "-defaultMatchGames %d\n", appData.defaultMatchGames);
+	fprintf(f, "-syncAfterRound %s\n", appData.roundSync ? "true" : "false");
+	fprintf(f, "-syncAfterCycle %s\n", appData.cycleSync ? "true" : "false");
+	fprintf(f, "-saveGameFile \"%s\"\n", appData.saveGameFile);
+	fprintf(f, "-loadGameFile \"%s\"\n", appData.loadGameFile);
+	fprintf(f, "-loadGameIndex %d\n", appData.loadGameIndex);
+	fprintf(f, "-loadPositionFile \"%s\"\n", appData.loadPositionFile);
+	fprintf(f, "-loadPositionIndex %d\n", appData.loadPositionIndex);
+	fprintf(f, "-rewindIndex %d\n", appData.rewindIndex);
+	if(searchTime > 0)
+		fprintf(f, "-searchTime \"%d:%02d\"\n", searchTime/60, searchTime%60);
+	else {
+		fprintf(f, "-mps %d\n", appData.movesPerSession);
+		fprintf(f, "-tc %s\n", appData.timeControl);
+		fprintf(f, "-inc %.2f\n", appData.timeIncrement);
+	}
+	fprintf(f, "-results \"%s\"\n", results);
+    }
+    return f;
+}
+
 int
 CreateTourney(char *name)
 {
 	FILE *f;
-	if(name[0] == NULLCHAR) return 0;
-	f = fopen(appData.tourneyFile, "r");
+	if(name[0] == NULLCHAR) {
+	    if(appData.participants[0])
+		DisplayError(_("You must supply a tournament file,\nfor storing the tourney progress"), 0);
+	    return 0;
+	}
+	f = fopen(name, "r");
 	if(f) { // file exists
+	    ASSIGN(appData.tourneyFile, name);
 	    ParseArgsFromFile(f); // parse it
 	} else {
-	    f = fopen(appData.tourneyFile, "w");
-	    if(f == NULL) { DisplayError("Could not write on tourney file", 0); return 0; } else {
-		// create a file with tournament description
-		fprintf(f, "-participants {%s}\n", appData.participants);
-		fprintf(f, "-tourneyType %d\n", appData.tourneyType);
-		fprintf(f, "-tourneyCycles %d\n", appData.tourneyCycles);
-		fprintf(f, "-defaultMatchGames %d\n", appData.defaultMatchGames);
-		fprintf(f, "-syncAfterRound %s\n", appData.roundSync ? "true" : "false");
-		fprintf(f, "-syncAfterCycle %s\n", appData.cycleSync ? "true" : "false");
-		fprintf(f, "-saveGameFile \"%s\"\n", appData.saveGameFile);
-		fprintf(f, "-loadGameFile \"%s\"\n", appData.loadGameFile);
-		fprintf(f, "-loadGameIndex %d\n", appData.loadGameIndex);
-		fprintf(f, "-loadPositionFile \"%s\"\n", appData.loadPositionFile);
-		fprintf(f, "-loadPositionIndex %d\n", appData.loadPositionIndex);
-		fprintf(f, "-rewindIndex %d\n", appData.rewindIndex);
-		if(searchTime > 0)
-			fprintf(f, "-searchTime \"%s\"\n", appData.searchTime);
-		else {
-			fprintf(f, "-mps %d\n", appData.movesPerSession);
-			fprintf(f, "-tc %s\n", appData.timeControl);
-			fprintf(f, "-inc %.2f\n", appData.timeIncrement);
-		}
-		fprintf(f, "-results \"\"\n");
+	    if(!appData.participants[0]) return 0; // ignore tourney file if non-existing & no participants
+	    if(CountPlayers(appData.participants) < (appData.tourneyType>0 ? appData.tourneyType+1 : 2)) {
+		DisplayError(_("Not enough participants"), 0);
+		return 0;
 	    }
+	    ASSIGN(appData.tourneyFile, name);
+	    if(appData.tourneyType < 0) appData.defaultMatchGames = 1; // Swiss forces games/pairing = 1
+	    if((f = WriteTourneyFile("")) == NULL) return 0;
 	}
 	fclose(f);
 	appData.noChessProgram = FALSE;
@@ -9581,6 +9825,7 @@ void SwapEngines(int n)
     SWAP(timeOdds, h)
     SWAP(logo, p)
     SWAP(pgnName, p)
+    SWAP(pvSAN, h)
 }
 
 void
@@ -9602,7 +9847,7 @@ SetPlayer(int player)
 int
 Pairing(int nr, int nPlayers, int *whitePlayer, int *blackPlayer, int *syncInterval)
 {   // determine players from game number
-    int curCycle, curRound, curPairing, gamesPerCycle, gamesPerRound, roundsPerCycle, pairingsPerRound;
+    int curCycle, curRound, curPairing, gamesPerCycle, gamesPerRound, roundsPerCycle=1, pairingsPerRound=1;
 
     if(appData.tourneyType == 0) {
 	roundsPerCycle = (nPlayers - 1) | 1;
@@ -9630,9 +9875,9 @@ Pairing(int nr, int nPlayers, int *whitePlayer, int *blackPlayer, int *syncInter
 	    *whitePlayer = curRound;
 	    *blackPlayer = nPlayers - 1; // this is the 'bye' when nPlayer is odd
 	} else {
-	    *whitePlayer = curRound - pairingsPerRound + curPairing;
+	    *whitePlayer = curRound - (nPlayers-1)/2 + curPairing;
 	    if(*whitePlayer < 0) *whitePlayer += nPlayers-1+(nPlayers&1);
-	    *blackPlayer = curRound + pairingsPerRound - curPairing;
+	    *blackPlayer = curRound + (nPlayers-1)/2 - curPairing;
 	    if(*blackPlayer >= nPlayers-1+(nPlayers&1)) *blackPlayer -= nPlayers-1+(nPlayers&1);
 	}
     } else if(appData.tourneyType > 0) {
@@ -9649,7 +9894,7 @@ int
 NextTourneyGame(int nr, int *swapColors)
 {   // !!!major kludge!!! fiddle appData settings to get everything in order for next tourney game
     char *p, *q;
-    int whitePlayer, blackPlayer, firstBusy=1000000000, syncInterval = 0, nPlayers=0;
+    int whitePlayer, blackPlayer, firstBusy=1000000000, syncInterval = 0, nPlayers;
     FILE *tf;
     if(appData.tourneyFile[0] == NULLCHAR) return 1; // no tourney, always allow next game
     tf = fopen(appData.tourneyFile, "r");
@@ -9657,9 +9902,9 @@ NextTourneyGame(int nr, int *swapColors)
     ParseArgsFromFile(tf); fclose(tf);
     InitTimeControls(); // TC might be altered from tourney file
 
-    p = appData.participants;
-    while(p = strchr(p, '\n')) p++, nPlayers++; // count participants
-    *swapColors = Pairing(nr, nPlayers, &whitePlayer, &blackPlayer, &syncInterval);
+    nPlayers = CountPlayers(appData.participants); // count participants
+    if(appData.tourneyType < 0) syncInterval = nPlayers/2; else
+    *swapColors = Pairing(nr<0 ? 0 : nr, nPlayers, &whitePlayer, &blackPlayer, &syncInterval);
 
     if(syncInterval) {
 	p = q = appData.results;
@@ -9673,6 +9918,29 @@ NextTourneyGame(int nr, int *swapColors)
 	waitingForGame = FALSE;
     }
 
+    if(appData.tourneyType < 0) {
+	if(nr>=0 && !pairingReceived) {
+	    char buf[1<<16];
+	    if(pairing.pr == NoProc) {
+		if(!appData.pairingEngine[0]) {
+		    DisplayFatalError(_("No pairing engine specified"), 0, 1);
+		    return 0;
+		}
+		StartChessProgram(&pairing); // starts the pairing engine
+	    }
+	    snprintf(buf, 1<<16, "results %d %s\n", nPlayers, appData.results);
+	    SendToProgram(buf, &pairing);
+	    snprintf(buf, 1<<16, "pairing %d\n", nr+1);
+	    SendToProgram(buf, &pairing);
+	    return 0; // wait for pairing engine to answer (which causes NextTourneyGame to be called again...
+	}
+	pairingReceived = 0;                              // ... so we continue here 
+	*swapColors = 0;
+	appData.matchGames = appData.tourneyCycles * syncInterval - 1;
+	whitePlayer = savedWhitePlayer-1; blackPlayer = savedBlackPlayer-1;
+	matchGame = 1; roundNr = nr / syncInterval + 1;
+    }
+
     if(first.pr != NoProc) return 1; // engines already loaded
 
     // redefine engines, engine dir, etc.
@@ -9684,6 +9952,7 @@ NextTourneyGame(int nr, int *swapColors)
     InitEngine(&first, 0);  // initialize ChessProgramStates based on new settings.
     InitEngine(&second, 1);
     CommonEngineInit();     // after this TwoMachinesEvent will create correct engine processes
+    UpdateLogos(FALSE);     // leave display to ModeHiglight()
     return 1;
 }
 
@@ -9833,7 +10102,7 @@ GameEnds(result, resultDetails, whosays)
 
 		// now verify win claims, but not in drop games, as we don't understand those yet
                 if( (gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
-						 || gameInfo.variant == VariantGreat) &&
+						 || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) &&
                     (result == WhiteWins && claimer == 'w' ||
                      result == BlackWins && claimer == 'b'   ) ) { // case to verify: engine claims own win
 		      if (appData.debugMode) {
@@ -9859,7 +10128,8 @@ GameEnds(result, resultDetails, whosays)
                 /* (Claiming a loss is accepted no questions asked!) */
 	    }
 	    /* [HGM] bare: don't allow bare King to win */
-	    if((gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
+	    if((gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
+					    || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand)
 	       && gameInfo.variant != VariantLosers && gameInfo.variant != VariantGiveaway
 	       && gameInfo.variant != VariantSuicide // [HGM] losers: except in losers, of course...
 	       && result != GameIsDrawn)
@@ -10078,9 +10348,10 @@ GameEnds(result, resultDetails, whosays)
 	}
 
 	if(waitingForGame) resChar = ' '; // quit while waiting for round sync: unreserve already reserved game
-	if(appData.tourneyFile[0] && !abortMatch){ // [HGM] we are in a tourney; update tourney file with game result
+	if(appData.tourneyFile[0]){ // [HGM] we are in a tourney; update tourney file with game result
 	    ReserveGame(nextGame, resChar); // sets nextGame
 	    if(nextGame > appData.matchGames) appData.tourneyFile[0] = 0, ranking = TourneyStandings(3); // tourney is done
+	    else ranking = strdup("busy"); //suppress popup when aborted but not finished
 	} else roundNr = nextGame = matchGame + 1; // normal match, just increment; round equals matchGame
 
 	if (nextGame <= appData.matchGames && !abortMatch) {
@@ -10096,6 +10367,7 @@ GameEnds(result, resultDetails, whosays)
 		     first.tidy, second.tidy,
 		     first.matchWins, second.matchWins,
 		     appData.matchGames - (first.matchWins + second.matchWins));
+	    if(!appData.tourneyFile[0]) matchGame++, DisplayTwoMachinesTitle(); // [HGM] update result in window title
 	    popupRequested++; // [HGM] crash: postpone to after resetting endingGame
 	    if (appData.firstPlaysBlack) { // [HGM] match: back to original for next match
 		first.twoMachinesColor = "black\n";
@@ -10115,11 +10387,13 @@ GameEnds(result, resultDetails, whosays)
     if(popupRequested) { // [HGM] crash: this calls GameEnds recursively through ExitEvent! Make it a harmless tail recursion.
 	if(matchMode == TRUE) { // match through command line: exit with or without popup
 	    if(ranking) {
+		ToNrEvent(forwardMostMove);
 		if(strcmp(ranking, "busy")) DisplayFatalError(ranking, 0, 0);
 		else ExitEvent(0);
 	    } else DisplayFatalError(buf, 0, 0);
 	} else { // match through menu; just stop, with or without popup
 	    matchMode = FALSE; appData.matchGames = matchGame = roundNr = 0;
+	    ModeHighlight();
 	    if(ranking){
 		if(strcmp(ranking, "busy")) DisplayNote(ranking);
 	    } else DisplayNote(buf);
@@ -10213,6 +10487,7 @@ Reset(redraw, init)
 		redraw, init, gameMode);
     }
     CleanupTail(); // [HGM] vari: delete any stored variations
+    CommentPopDown(); // [HGM] make sure no comments to the previous game keep hanging on
     pausing = pauseExamInvalid = FALSE;
     startedFromSetupPosition = blackPlaysFirst = FALSE;
     firstMove = TRUE;
@@ -10320,8 +10595,8 @@ AutoPlayOneMove()
 
     if (currentMove >= forwardMostMove) {
       if(gameMode == AnalyzeFile) { ExitAnalyzeMode(); SendToProgram("force\n", &first); }
-      gameMode = EditGame;
-      ModeHighlight();
+//      gameMode = EndOfGame;
+//      ModeHighlight();
 
       /* [AS] Clear current move marker at the end of a game */
       /* HistorySet(parseList, backwardMostMove, forwardMostMove, -1); */
@@ -10768,7 +11043,133 @@ ReloadGame(offset)
     }
 }
 
+int keys[EmptySquare+1];
 
+int
+PositionMatches(Board b1, Board b2)
+{
+    int r, f, sum=0;
+    switch(appData.searchMode) {
+	case 1: return CompareWithRights(b1, b2);
+	case 2:
+	    for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
+		if(b2[r][f] != EmptySquare && b1[r][f] != b2[r][f]) return FALSE;
+	    }
+	    return TRUE;
+	case 3:
+	    for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
+	      if((b2[r][f] == WhitePawn || b2[r][f] == BlackPawn) && b1[r][f] != b2[r][f]) return FALSE;
+		sum += keys[b1[r][f]] - keys[b2[r][f]];
+	    }
+	    return sum==0;
+	case 4:
+	    for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
+		sum += keys[b1[r][f]] - keys[b2[r][f]];
+	    }
+	    return sum==0;
+    }
+    return TRUE;
+}
+
+GameInfo dummyInfo;
+
+int GameContainsPosition(FILE *f, ListGame *lg)
+{
+    int next, btm=0, plyNr=0, scratch=forwardMostMove+2&~1;
+    int fromX, fromY, toX, toY;
+    char promoChar;
+    static int initDone=FALSE;
+
+    if(!initDone) {
+	for(next = WhitePawn; next<EmptySquare; next++) keys[next] = rand()>>8 ^ rand()<<6 ^rand()<<20;
+	initDone = TRUE;
+    }
+    dummyInfo.variant = VariantNormal;
+    FREE(dummyInfo.fen); dummyInfo.fen = NULL;
+    dummyInfo.whiteRating = 0;
+    dummyInfo.blackRating = 0;
+    FREE(dummyInfo.date); dummyInfo.date = NULL;
+    fseek(f, lg->offset, 0);
+    yynewfile(f);
+    CopyBoard(boards[scratch], initialPosition); // default start position
+    while(1) {
+	yyboardindex = scratch + (plyNr&1);
+      quickFlag = 1;
+	next = Myylex();
+      quickFlag = 0;
+	switch(next) {
+	    case PGNTag:
+		if(plyNr) return -1; // after we have seen moves, any tags will be start of next game
+		ParsePGNTag(yy_text, &dummyInfo);
+	    if(dummyInfo.fen) ParseFEN(boards[scratch], &btm, dummyInfo.fen), free(dummyInfo.fen), dummyInfo.fen = NULL;
+	    default:
+		continue;
+
+	    case XBoardGame:
+	    case GNUChessGame:
+		if(plyNr) return -1; // after we have seen moves, this is for new game
+	      continue;
+
+	    case AmbiguousMove: // we cannot reconstruct the game beyond these two
+	    case ImpossibleMove:
+	    case WhiteWins: // game ends here with these four
+	    case BlackWins:
+	    case GameIsDrawn:
+	    case GameUnfinished:
+		return -1;
+
+	    case IllegalMove:
+		if(appData.testLegality) return -1;
+	    case WhiteCapturesEnPassant:
+	    case BlackCapturesEnPassant:
+	    case WhitePromotion:
+	    case BlackPromotion:
+	    case WhiteNonPromotion:
+	    case BlackNonPromotion:
+	    case NormalMove:
+	    case WhiteKingSideCastle:
+	    case WhiteQueenSideCastle:
+	    case BlackKingSideCastle:
+	    case BlackQueenSideCastle:
+	    case WhiteKingSideCastleWild:
+	    case WhiteQueenSideCastleWild:
+	    case BlackKingSideCastleWild:
+	    case BlackQueenSideCastleWild:
+	    case WhiteHSideCastleFR:
+	    case WhiteASideCastleFR:
+	    case BlackHSideCastleFR:
+	    case BlackASideCastleFR:
+		fromX = currentMoveString[0] - AAA;
+		fromY = currentMoveString[1] - ONE;
+		toX = currentMoveString[2] - AAA;
+		toY = currentMoveString[3] - ONE;
+		promoChar = currentMoveString[4];
+		break;
+	    case WhiteDrop:
+	    case BlackDrop:
+		fromX = next == WhiteDrop ?
+		  (int) CharToPiece(ToUpper(currentMoveString[0])) :
+		  (int) CharToPiece(ToLower(currentMoveString[0]));
+		fromY = DROP_RANK;
+		toX = currentMoveString[2] - AAA;
+		toY = currentMoveString[3] - ONE;
+		break;
+	}
+	// Move encountered; peform it. We need to shuttle between two boards, as even/odd index determines side to move
+	if(plyNr == 0) { // but first figure out variant and initial position
+	    if(dummyInfo.variant != gameInfo.variant) return -1; // wrong variant
+	    if(appData.eloThreshold1 && (dummyInfo.whiteRating < appData.eloThreshold1 && dummyInfo.blackRating < appData.eloThreshold1)) return -1;
+	    if(appData.eloThreshold2 && (dummyInfo.whiteRating < appData.eloThreshold2 || dummyInfo.blackRating < appData.eloThreshold2)) return -1;
+	    if(appData.dateThreshold && (!dummyInfo.date || atoi(dummyInfo.date) < appData.dateThreshold)) return -1;
+	    if(btm) CopyBoard(boards[scratch+1], boards[scratch]), plyNr++;
+	    if(PositionMatches(boards[scratch + plyNr], boards[currentMove])) return plyNr;
+	}
+	CopyBoard(boards[scratch + (plyNr+1&1)], boards[scratch + (plyNr&1)]);
+	plyNr++;
+	ApplyMove(fromX, fromY, toX, toY, promoChar, boards[scratch + (plyNr&1)]);
+	if(PositionMatches(boards[scratch + (plyNr&1)], boards[currentMove])) return plyNr;
+    }
+}
 
 /* Load the nth game from open file f */
 int
@@ -10783,7 +11184,7 @@ LoadGame(f, gameNumber, title, useList)
     int gn = gameNumber;
     ListGame *lg = NULL;
     int numPGNTags = 0;
-    int err;
+    int err, pos = -1;
     GameMode oldGameMode;
     VariantClass oldVariant = gameInfo.variant; /* [HGM] PGNvariant */
 
@@ -10809,6 +11210,7 @@ LoadGame(f, gameNumber, title, useList)
 	if (lg) {
 	    fseek(f, lg->offset, 0);
 	    GameListHighlight(gameNumber);
+	    pos = lg->position;
 	    gn = 1;
 	}
 	else {
@@ -11208,10 +11610,11 @@ LoadGame(f, gameNumber, title, useList)
       AnalyzeFileEvent();
     }
 
+    if (!matchMode && pos >= 0) {
+	ToNrEvent(pos); // [HGM] no autoplay if selected on position
+    } else
     if (matchMode || appData.timeDelay == 0) {
       ToEndEvent();
-      gameMode = EditGame;
-      ModeHighlight();
     } else if (appData.timeDelay > 0) {
       AutoPlayGameLoop();
     }
@@ -12248,6 +12651,9 @@ ExitEvent(status)
 	RemoveInputSource(second.isr);
     }
 
+    if (pairing.pr != NoProc) SendToProgram("quit\n", &pairing);
+    if (pairing.isr != NULL) RemoveInputSource(pairing.isr);
+
     ShutDownFrontEnd();
     exit(status);
 }
@@ -12559,6 +12965,12 @@ DisplayTwoMachinesTitle()
 {
     char buf[MSG_SIZ];
     if (appData.matchGames > 0) {
+        if(appData.tourneyFile[0]) {
+	  snprintf(buf, MSG_SIZ, "%s vs. %s (%d/%d%s)",
+		   gameInfo.white, gameInfo.black,
+		   nextGame+1, appData.matchGames+1,
+		   appData.tourneyType>0 ? "gt" : appData.tourneyType<0 ? "sw" : "rr");
+        } else 
         if (first.twoMachinesColor[0] == 'w') {
 	  snprintf(buf, MSG_SIZ, "%s vs. %s (%d-%d-%d)",
 		   gameInfo.white, gameInfo.black,
@@ -12689,7 +13101,7 @@ TwoMachinesEvent P((void))
 
     gameMode = TwoMachinesPlay;
     pausing = FALSE;
-    ModeHighlight();
+    ModeHighlight(); // [HGM] logo: this triggers display update of logos
     SetGameInfo();
     DisplayTwoMachinesTitle();
     firstMove = TRUE;
@@ -13318,7 +13730,9 @@ ClockClick(int which)
 	  if (gameMode == EditPosition || gameMode == IcsExamining) {
 	    if(!appData.pieceMenu && blackPlaysFirst) EditPositionMenuEvent(ClearBoard, 0, 0);
 	    SetBlackToPlayEvent();
-	  } else if (gameMode == EditGame || shiftKey) {
+	  } else if ((gameMode == AnalyzeMode || gameMode == EditGame) && !blackFlag && WhiteOnMove(currentMove)) {
+          UserMoveEvent((int)EmptySquare, DROP_RANK, 0, 0, 0); // [HGM] multi-move: if not out of time, enters null move
+	  } else if (shiftKey) {
 	    AdjustClock(which, -1);
 	  } else if (gameMode == IcsPlayingWhite ||
 	             gameMode == MachinePlaysBlack) {
@@ -13328,7 +13742,9 @@ ClockClick(int which)
 	  if (gameMode == EditPosition || gameMode == IcsExamining) {
 	    if(!appData.pieceMenu && !blackPlaysFirst) EditPositionMenuEvent(ClearBoard, 0, 0);
 	    SetWhiteToPlayEvent();
-	  } else if (gameMode == EditGame || shiftKey) {
+	  } else if ((gameMode == AnalyzeMode || gameMode == EditGame) && !whiteFlag && !WhiteOnMove(currentMove)) {
+          UserMoveEvent((int)EmptySquare, DROP_RANK, 0, 0, 0); // [HGM] multi-move
+	  } else if (shiftKey) {
 	    AdjustClock(which, -1);
 	  } else if (gameMode == IcsPlayingBlack ||
 	           gameMode == MachinePlaysWhite) {
@@ -13605,6 +14021,16 @@ BackwardInner(target)
     if (gameMode == EditGame || gameMode==AnalyzeMode ||
 	gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
 	while (currentMove > target) {
+	    if(moveList[currentMove-1][1] == '@' && moveList[currentMove-1][0] == '@') {
+		// null move cannot be undone. Reload program with move history before it.
+		int i;
+		for(i=target; i>backwardMostMove; i--) { // seek back to start or previous null move
+		    if(moveList[i-1][1] == '@' && moveList[i-1][0] == '@') break;
+		}
+		SendBoard(&first, i); 
+		for(currentMove=i; currentMove<target; currentMove++) SendMoveToProgram(currentMove, &first);
+		break;
+	    }
 	    SendToProgram("undo\n", &first);
 	    currentMove--;
 	}
@@ -14309,6 +14735,7 @@ ReceiveFromProgram(isr, closure, message, count, error)
     if (count <= 0) {
 	if (count == 0) {
 	    RemoveInputSource(cps->isr);
+	    if(!cps->initDone) return; // [HGM] should not generate fatal error during engine load
 	    snprintf(buf, MSG_SIZ, _("Error: %s chess program (%s) exited unexpectedly"),
 		    _(cps->which), cps->program);
         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
@@ -14860,14 +15287,14 @@ AskQuestionEvent(title, question, replyPrefix, which)
 void
 TypeInEvent(char firstChar)
 {
-    if ((gameMode == BeginningOfGame && !appData.icsActive) || 
-        gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
-	gameMode == AnalyzeMode || gameMode == EditGame || 
-	gameMode == EditPosition || gameMode == IcsExamining ||
-	gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
-	isdigit(firstChar) && // [HGM] movenum: allow typing in of move nr in 'passive' modes
-		( gameMode == AnalyzeFile || gameMode == PlayFromGameFile ||
-		  gameMode == IcsObserving || gameMode == TwoMachinesPlay    ) ||
+    if ((gameMode == BeginningOfGame && !appData.icsActive) || 
+        gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
+	gameMode == AnalyzeMode || gameMode == EditGame || 
+	gameMode == EditPosition || gameMode == IcsExamining ||
+	gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
+	isdigit(firstChar) && // [HGM] movenum: allow typing in of move nr in 'passive' modes
+		( gameMode == AnalyzeFile || gameMode == PlayFromGameFile ||
+		  gameMode == IcsObserving || gameMode == TwoMachinesPlay    ) ||
 	gameMode == Training) PopUpMoveDialog(firstChar);
 }
 
@@ -14877,34 +15304,34 @@ TypeInDoneEvent(char *move)
 	Board board;
 	int n, fromX, fromY, toX, toY;
 	char promoChar;
-	ChessMove moveType;
-
-	// [HGM] FENedit
-	if(gameMode == EditPosition && ParseFEN(board, &n, move) ) {
-		EditPositionPasteFEN(move);
-		return;
-	}
-	// [HGM] movenum: allow move number to be typed in any mode
-	if(sscanf(move, "%d", &n) == 1 && n != 0 ) {
-	  ToNrEvent(2*n-1);
-	  return;
-	}
-
-      if (gameMode != EditGame && currentMove != forwardMostMove && 
-	gameMode != Training) {
-	DisplayMoveError(_("Displayed move is not current"));
-      } else {
-	int ok = ParseOneMove(move, gameMode == EditPosition ? blackPlaysFirst : currentMove, 
-	  &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
-	if(!ok && move[0] >= 'a') { move[0] += 'A' - 'a'; ok = 2; } // [HGM] try also capitalized
-	if (ok==1 || ok && ParseOneMove(move, gameMode == EditPosition ? blackPlaysFirst : currentMove, 
-	  &moveType, &fromX, &fromY, &toX, &toY, &promoChar)) {
-	  UserMoveEvent(fromX, fromY, toX, toY, promoChar);	
-	} else {
-	  DisplayMoveError(_("Could not parse move"));
-	}
-      }
-}
+	ChessMove moveType;
+
+	// [HGM] FENedit
+	if(gameMode == EditPosition && ParseFEN(board, &n, move) ) {
+		EditPositionPasteFEN(move);
+		return;
+	}
+	// [HGM] movenum: allow move number to be typed in any mode
+	if(sscanf(move, "%d", &n) == 1 && n != 0 ) {
+	  ToNrEvent(2*n-1);
+	  return;
+	}
+
+      if (gameMode != EditGame && currentMove != forwardMostMove && 
+	gameMode != Training) {
+	DisplayMoveError(_("Displayed move is not current"));
+      } else {
+	int ok = ParseOneMove(move, gameMode == EditPosition ? blackPlaysFirst : currentMove, 
+	  &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
+	if(!ok && move[0] >= 'a') { move[0] += 'A' - 'a'; ok = 2; } // [HGM] try also capitalized
+	if (ok==1 || ok && ParseOneMove(move, gameMode == EditPosition ? blackPlaysFirst : currentMove, 
+	  &moveType, &fromX, &fromY, &toX, &toY, &promoChar)) {
+	  UserMoveEvent(fromX, fromY, toX, toY, promoChar);	
+	} else {
+	  DisplayMoveError(_("Could not parse move"));
+	}
+      }
+}
 
 void
 DisplayMove(moveNumber)
@@ -14970,8 +15397,6 @@ DisplayComment(moveNumber, text)
      char *text;
 {
     char title[MSG_SIZ];
-    char buf[8000]; // comment can be long!
-    int score, depth;
 
     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
       safeStrCpy(title, "Comment", sizeof(title)/sizeof(title[0]));
@@ -14980,14 +15405,6 @@ DisplayComment(moveNumber, text)
 	      WhiteOnMove(moveNumber) ? " " : ".. ",
 	      parseList[moveNumber]);
     }
-    // [HGM] PV info: display PV info together with (or as) comment
-    if(moveNumber >= 0 && (depth = pvInfoList[moveNumber].depth) > 0) {
-      if(text == NULL) text = "";
-      score = pvInfoList[moveNumber].score;
-      snprintf(buf,sizeof(buf)/sizeof(buf[0]), "%s%.2f/%d %d\n%s", score>0 ? "+" : "", score/100.,
-	      depth, (pvInfoList[moveNumber].time+50)/100, text);
-      text = buf;
-    }
     if (text != NULL && (appData.autoDisplayComment || commentUp))
         CommentPopUp(title, text);
 }
@@ -15592,7 +16009,7 @@ PositionToFEN(move, overrideCastling)
 {
     int i, j, fromX, fromY, toX, toY;
     int whiteToPlay;
-    char buf[128];
+    char buf[MSG_SIZ];
     char *p, *q;
     int emptycount;
     ChessSquare piece;
@@ -15603,6 +16020,7 @@ PositionToFEN(move, overrideCastling)
 
     /* Piece placement data */
     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
+	if(MSG_SIZ - (p - buf) < BOARD_RGHT - BOARD_LEFT + 20) { *p = 0; return StrSave(buf); }
 	emptycount = 0;
         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
 	    if (boards[move][i][j] == EmptySquare) {
@@ -16127,6 +16545,7 @@ int wrap(char *dest, char *src, int count, int width, int *lp)
 }
 
 // [HGM] vari: routines for shelving variations
+Boolean modeRestore = FALSE;
 
 void
 PushInner(int firstMove, int lastMove)
@@ -16170,6 +16589,7 @@ PushTail(int firstMove, int lastMove)
 
 	PushInner(firstMove, lastMove);
 	if(storedGames == 1) GreyRevert(FALSE);
+	if(gameMode == PlayFromGameFile) gameMode = EditGame, modeRestore = TRUE;
 }
 
 void
@@ -16178,8 +16598,8 @@ PopInner(Boolean annotate)
 	int i, j, nrMoves;
 	char buf[8000], moveBuf[20];
 
-	storedGames--;
-	ToNrEvent(savedFirst[storedGames]); // sets currentMove
+	ToNrEvent(savedFirst[storedGames-1]); // sets currentMove
+	storedGames--; // do this after ToNrEvent, to make sure HistorySet will refresh entire game after PopInner returns
 	nrMoves = savedLast[storedGames] - currentMove;
 	if(annotate) {
 		int cnt = 10;
@@ -16227,8 +16647,10 @@ PopTail(Boolean annotate)
 	CommentPopDown(); // make sure no stale variation comments to the destroyed line can remain open
 
 	PopInner(annotate);
+	if(currentMove < forwardMostMove) ForwardEvent(); else
+	HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
 
-	if(storedGames == 0) GreyRevert(TRUE);
+	if(storedGames == 0) { GreyRevert(TRUE); if(modeRestore) modeRestore = FALSE, gameMode = PlayFromGameFile; }
 	return TRUE;
 }
 
@@ -16255,7 +16677,7 @@ LoadVariation(int index, char *text)
 	char *p = text, *start = NULL, *end = NULL, wait = NULLCHAR;
 	int level = 0, move;
 
-	if(gameMode != EditGame && gameMode != AnalyzeMode) return;
+	if(gameMode != EditGame && gameMode != AnalyzeMode && gameMode != PlayFromGameFile) return;
 	// first find outermost bracketing variation
 	while(*p) { // hope I got this right... Non-nesting {} and [] can screen each other and nesting ()
 	    if(!wait) { // while inside [] pr {}, ignore everyting except matching closing ]}