X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=backend.c;h=f7c75b68b2634426b6ffbfa54a7199cd4d2f2cd5;hb=e10b34662822bd8dc06680b6b9977966816450de;hp=8f77f6b8ff40922edeb5bb72b744a216d1e48cd7;hpb=cf82d6c8eff0e13a4700deba98f8033e6e8ad605;p=xboard.git

diff --git a/backend.c b/backend.c
index 8f77f6b..f7c75b6 100644
--- a/backend.c
+++ b/backend.c
@@ -132,8 +132,13 @@ extern int gettimeofday(struct timeval *, struct timezone *);
 # define _(s) gettext (s) 
 # define N_(s) gettext_noop (s) 
 #else 
-# define _(s) (s) 
-# define N_(s) s 
+# ifdef WIN32
+#   define _(s) T_(s)
+#   define N_(s) s
+# else
+#   define _(s) (s) 
+#   define N_(s) s 
+# endif
 #endif 
 
 
@@ -234,6 +239,7 @@ char *ProbeBook P((int moveNr, char *book)); // [HGM] book: returns a book move
 char *SendMoveToBookUser P((int nr, ChessProgramState *cps, int initial)); // [HGM] book
 void ics_update_width P((int new_width));
 extern char installDir[MSG_SIZ];
+VariantClass startVariant; /* [HGM] nicks: initial variant */
 
 extern int tinyLayout, smallLayout;
 ChessProgramStats programStats;
@@ -242,6 +248,13 @@ int endPV = -1;
 static int exiting = 0; /* [HGM] moved to top */
 static int setboardSpoiledMachineBlack = 0 /*, errorExitFlag = 0*/;
 int startedFromPositionFile = FALSE; Board filePosition;       /* [HGM] loadPos */
+Board partnerBoard;     /* [HGM] bughouse: for peeking at partner game          */
+int partnerHighlight[2];
+Boolean partnerBoardValid = 0;
+char partnerStatus[MSG_SIZ];
+Boolean partnerUp;
+Boolean originalFlip;
+Boolean twoBoards = 0;
 char endingGame = 0;    /* [HGM] crash: flag to prevent recursion of GameEnds() */
 int whiteNPS, blackNPS; /* [HGM] nps: for easily making clocks aware of NPS     */
 VariantClass currentlyInitializedVariant; /* [HGM] variantswitch */
@@ -630,6 +643,7 @@ InitBackEnd1()
     int matched, min, sec;
 
     ShowThinkingEvent(); // [HGM] thinking: make sure post/nopost state is set according to options
+    startVariant = StringToVariant(appData.variant); // [HGM] nicks: remember original variant
 
     GetTimeMark(&programStartTime);
     srandom((programStartTime.ms + 1000*programStartTime.sec)*0x1001001); // [HGM] book: makes sure random is unpredictabe to msec level
@@ -705,8 +719,8 @@ InitBackEnd1()
     /* [AS] Adjudication threshold */
     adjudicateLossThreshold = appData.adjudicateLossThreshold;
     
-    first.which = "first";
-    second.which = "second";
+    first.which = _("first");
+    second.which = _("second");
     first.maybeThinking = second.maybeThinking = FALSE;
     first.pr = second.pr = NoProc;
     first.isr = second.isr = NULL;
@@ -1101,6 +1115,11 @@ InitBackEnd3 P((void))
 
     InitChessProgram(&first, startedFromSetupPosition);
 
+    if(!appData.noChessProgram) {  /* [HGM] tidy: redo program version to use name from myname feature */
+	free(programVersion);
+	programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
+	sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
+    }
 
     if (appData.icsActive) {
 #ifdef WIN32
@@ -1339,6 +1358,19 @@ establish()
     }
 }
 
+void EscapeExpand(char *p, char *q)
+{	// [HGM] initstring: routine to shape up string arguments
+	while(*p++ = *q++) if(p[-1] == '\\')
+	    switch(*q++) {
+		case 'n': p[-1] = '\n'; break;
+		case 'r': p[-1] = '\r'; break;
+		case 't': p[-1] = '\t'; break;
+		case '\\': p[-1] = '\\'; break;
+		case 0: *p = 0; return;
+		default: p[-1] = q[-1]; break;
+	    }
+}
+
 void
 show_bytes(fp, buf, count)
      FILE *fp;
@@ -1971,7 +2003,7 @@ void
 VariantSwitch(Board board, VariantClass newVariant)
 {
    int newHoldingsWidth, newWidth = 8, newHeight = 8, i, j;
-   Board oldBoard;
+   static Board oldBoard;
 
    startedFromPositionFile = FALSE;
    if(gameInfo.variant == newVariant) return;
@@ -2087,7 +2119,7 @@ PlotSeekAd(int i)
 	if(r > maxRating) r = maxRating;
 	if(tc < 1.) tc = 1.;
 	if(tc > 95.) tc = 95.;
-	x = (w-hMargin)* log(tc)/log(100.) + hMargin;
+	x = (w-hMargin-squareSize/8-7)* log(tc)/log(95.) + hMargin;
 	y = ((double)r - minRating)/(maxRating - minRating)
 	    * (h-vMargin-squareSize/8-1) + vMargin;
 	if(ratingList[i] < 0) y = vMargin + squareSize/4;
@@ -2179,8 +2211,8 @@ MatchSoughtLine(char *line)
 int
 DrawSeekGraph()
 {
-    if(!seekGraphUp) return FALSE;
     int i;
+    if(!seekGraphUp) return FALSE;
     h = BOARD_HEIGHT * (squareSize + lineGap) + lineGap;
     w = BOARD_WIDTH  * (squareSize + lineGap) + lineGap;
 
@@ -2199,7 +2231,7 @@ DrawSeekGraph()
     }
     DrawSeekText("unrated", hMargin+squareSize/8+7, h-1-vMargin-squareSize/4);
     for(i=1; i<100; i+=(i<10?1:5)) {
-	int xx = (w-hMargin)* log((double)i)/log(100.) + hMargin;
+	int xx = (w-hMargin-squareSize/8-7)* log((double)i)/log(95.) + hMargin;
 	DrawSeekAxis(xx, h-1-vMargin, xx, h-6-vMargin-3*(i%10==0)); // TC ticks
 	if(i<=5 || (i>40 ? i%20 : i%10) == 0) {
 	    char buf[MSG_SIZ];
@@ -2235,15 +2267,16 @@ int SeekGraphClick(ClickType click, int x, int y, int moving)
 		DisplayMessage(second ? "!" : "", seekAdList[closest]);
 		lastSecond = second; displayed = closest;
 	    }
-	    sprintf(buf, "play %d\n", seekNrList[closest]);
 	    if(click == Press) {
 		if(moving == 2) zList[closest] = 100; // right-click; push to back on press
 		lastDown = closest;
 		return TRUE;
 	    } // on press 'hit', only show info
 	    if(moving == 2) return TRUE; // ignore right up-clicks on dot
+	    sprintf(buf, "play %d\n", seekNrList[closest]);
 	    SendToICS(ics_prefix);
-	    SendToICS(buf); // should this be "sought all"?
+	    SendToICS(buf);
+	    return TRUE; // let incoming board of started game pop down the graph
 	} else if(click == Release) { // release 'miss' is ignored
 	    zList[lastDown] = 100; // make future selection of the rejected ad more difficult
 	    if(moving == 2) { // right up-click
@@ -2539,6 +2572,7 @@ read_from_ics(isr, closure, data, count, error)
 			sprintf(mess, "%s%s", talker, parse);
 			OutputChatMessage(chattingPartner, mess);
 			chattingPartner = -1;
+			next_out = i+1; // [HGM] suppress printing in ICS window
 		    } else
 		    if(!suppressKibitz) // [HGM] kibitz
 			AppendComment(forwardMostMove, StripHighlight(parse), TRUE);
@@ -2562,12 +2596,12 @@ read_from_ics(isr, closure, data, count, error)
 				pvInfoList[forwardMostMove-1].score = 100*score;
 			    }
 			    OutputKibitz(suppressKibitz, parse);
-			    next_out = i+1; // [HGM] suppress printing in ICS window
 			} else {
 			    char tmp[MSG_SIZ];
 			    sprintf(tmp, _("your opponent kibitzes: %s"), parse);
 			    SendToPlayer(tmp, strlen(tmp));
 			}
+			next_out = i+1; // [HGM] suppress printing in ICS window
 		    }
 		    started = STARTED_NONE;
 		} else {
@@ -2583,6 +2617,7 @@ read_from_ics(isr, closure, data, count, error)
 		    continue;
 		}
 		started = STARTED_NONE;
+		if(suppressKibitz) next_out = i+1;
 	    }
 
             /* Kludge to deal with rcmd protocol */
@@ -2640,10 +2675,12 @@ read_from_ics(isr, closure, data, count, error)
 	      continue;
 	    }
 
+	    oldi = i;
 	    // [HGM] seekgraph: recognize sought lines and end-of-sought message
 	    if(appData.seekGraph) {
 		if(soughtPending && MatchSoughtLine(buf+i)) {
 		    i = strstr(buf+i, "rated") - buf;
+		    if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
 		    next_out = leftover_start = i;
 		    started = STARTED_CHATTER;
 		    suppressKibitz = TRUE;
@@ -2663,16 +2700,19 @@ read_from_ics(isr, closure, data, count, error)
 			AddAd(star_match[0], star_match[1], atoi(star_match[2+s]), atoi(star_match[3+s]), 
 			      star_match[4+s][0], star_match[5-3*s], atoi(star_match[7]), TRUE);
 			looking_at(buf, &i, "*% "); // eat prompt
+			if(oldi > 0 && buf[oldi-1] == '\n') oldi--; // suppress preceding LF, if any
+			if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
 			next_out = i; // suppress
 			continue;
 		    }
-		    if(looking_at(buf, &i, "Ads removed: *\n") || looking_at(buf, &i, "\031(51 * *\031)")) {
+		    if(looking_at(buf, &i, "\nAds removed: *\n") || looking_at(buf, &i, "\031(51 * *\031)")) {
 			char *p = star_match[0];
 			while(*p) {
 			    if(seekGraphUp) RemoveSeekAd(atoi(p));
 			    while(*p && *p++ != ' '); // next
 			}
 			looking_at(buf, &i, "*% "); // eat prompt
+			if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
 			next_out = i;
 			continue;
 		    }
@@ -2687,15 +2727,16 @@ read_from_ics(isr, closure, data, count, error)
 	      continue;
 	    }
 
-	    oldi = i;
 	    // [HGM] kibitz: try to recognize opponent engine-score kibitzes, to divert them to engine-output window
 	    if (appData.autoKibitz && started == STARTED_NONE && 
                 !appData.icsEngineAnalyze &&                     // [HGM] [DM] ICS analyze
 		(gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack || gameMode == IcsObserving)) {
-		if(looking_at(buf, &i, "* kibitzes: ") &&
+		if((looking_at(buf, &i, "* kibitzes: ") || looking_at(buf, &i, "* whispers: ")) &&
 		   (StrStr(star_match[0], gameInfo.white) == star_match[0] || 
 		    StrStr(star_match[0], gameInfo.black) == star_match[0]   )) { // kibitz of self or opponent
 		    	suppressKibitz = TRUE;
+			if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
+			next_out = i;
 			if((StrStr(star_match[0], gameInfo.white) == star_match[0]
 				&& (gameMode == IcsPlayingWhite)) ||
 			   (StrStr(star_match[0], gameInfo.black) == star_match[0]
@@ -2710,24 +2751,33 @@ read_from_ics(isr, closure, data, count, error)
 			} 
 			continue;
 		} else
-		if(looking_at(buf, &i, "kibitzed to *\n") && atoi(star_match[0])) {
+		if((looking_at(buf, &i, "\nkibitzed to *\n") || looking_at(buf, &i, "kibitzed to *\n") ||
+		    looking_at(buf, &i, "\n(kibitzed to *\n") || looking_at(buf, &i, "(kibitzed to *\n"))
+			 && atoi(star_match[0])) {
 		    // suppress the acknowledgements of our own autoKibitz
 		    char *p;
+		    if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
 		    if(p = strchr(star_match[0], ' ')) p[1] = NULLCHAR; // clip off "players)" on FICS
 		    SendToPlayer(star_match[0], strlen(star_match[0]));
-		    looking_at(buf, &i, "*% "); // eat prompt
+		    if(looking_at(buf, &i, "*% ")) // eat prompt
+			suppressKibitz = FALSE;
 		    next_out = i;
+		    continue;
 		}
 	    } // [HGM] kibitz: end of patch
 
-//if(appData.debugMode) fprintf(debugFP, "hunt for tell, buf = %s\n", buf+i);
-
 	    // [HGM] chat: intercept tells by users for which we have an open chat window
 	    channel = -1;
 	    if(started == STARTED_NONE && (looking_at(buf, &i, "* tells you:") || looking_at(buf, &i, "* says:") || 
 					   looking_at(buf, &i, "* whispers:") ||
+					   looking_at(buf, &i, "* kibitzes:") ||
+					   looking_at(buf, &i, "* shouts:") ||
+					   looking_at(buf, &i, "* c-shouts:") ||
+					   looking_at(buf, &i, "--> * ") ||
 					   looking_at(buf, &i, "*(*):") && (sscanf(star_match[1], "%d", &channel),1) ||
-					   looking_at(buf, &i, "*(*)(*):") && sscanf(star_match[2], "%d", &channel) == 1 )) {
+					   looking_at(buf, &i, "*(*)(*):") && (sscanf(star_match[2], "%d", &channel),1) ||
+					   looking_at(buf, &i, "*(*)(*)(*):") && (sscanf(star_match[3], "%d", &channel),1) ||
+					   looking_at(buf, &i, "*(*)(*)(*)(*):") && sscanf(star_match[4], "%d", &channel) == 1 )) {
 		int p;
 		sscanf(star_match[0], "%[^(]", talker+1); // strip (C) or (U) off ICS handle
 		chattingPartner = -1;
@@ -2736,26 +2786,56 @@ read_from_ics(isr, closure, data, count, error)
 		for(p=0; p<MAX_CHAT; p++) {
 		    if(channel == atoi(chatPartner[p])) {
 		    talker[0] = '['; strcat(talker, "] ");
+		    Colorize(channel == 1 ? ColorChannel1 : ColorChannel, FALSE);
 		    chattingPartner = p; break;
 		    }
 		} else
+		if(buf[i-3] == 'e') // kibitz; look if there is a KIBITZ chatbox
+		for(p=0; p<MAX_CHAT; p++) {
+		    if(!strcmp("kibitzes", chatPartner[p])) {
+			talker[0] = '['; strcat(talker, "] ");
+			chattingPartner = p; break;
+		    }
+		} else
 		if(buf[i-3] == 'r') // whisper; look if there is a WHISPER chatbox
 		for(p=0; p<MAX_CHAT; p++) {
-		    if(!strcmp("WHISPER", chatPartner[p])) {
+		    if(!strcmp("whispers", chatPartner[p])) {
 			talker[0] = '['; strcat(talker, "] ");
 			chattingPartner = p; break;
 		    }
+		} else
+		if(buf[i-3] == 't' || buf[oldi+2] == '>') {// shout, c-shout or it; look if there is a 'shouts' chatbox
+		  if(buf[i-8] == '-' && buf[i-3] == 't')
+		  for(p=0; p<MAX_CHAT; p++) { // c-shout; check if dedicatesd c-shout box exists
+		    if(!strcmp("c-shouts", chatPartner[p])) {
+			talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE);
+			chattingPartner = p; break;
+		    }
+		  }
+		  if(chattingPartner < 0)
+		  for(p=0; p<MAX_CHAT; p++) {
+		    if(!strcmp("shouts", chatPartner[p])) {
+			if(buf[oldi+2] == '>') { talker[0] = '<'; strcat(talker, "> "); Colorize(ColorShout, FALSE); }
+			else if(buf[i-8] == '-') { talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE); }
+			else { talker[0] = '['; strcat(talker, "] "); Colorize(ColorShout, FALSE); }
+			chattingPartner = p; break;
+		    }
+		  }
 		}
 		if(chattingPartner<0) // if not, look if there is a chatbox for this indivdual
 		for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
-		    talker[0] = 0;
+		    talker[0] = 0; Colorize(ColorTell, FALSE);
 		    chattingPartner = p; break;
 		}
 		if(chattingPartner<0) i = oldi; else {
+		    Colorize(curColor, TRUE); // undo the bogus colorations we just made to trigger the souds
+		    if(oldi > 0 && buf[oldi-1] == '\n') oldi--;
+		    if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
 		    started = STARTED_COMMENT;
 		    parse_pos = 0; parse[0] = NULLCHAR;
 		    savingComment = 3 + chattingPartner; // counts as TRUE
 		    suppressKibitz = TRUE;
+		    continue;
 		}
 	    } // [HGM] chat: end of patch
 
@@ -2763,18 +2843,9 @@ read_from_ics(isr, closure, data, count, error)
                 /* [DM] Backup address for color zippy lines */
                 backup = i;
 #if ZIPPY
-       #ifdef WIN32
                if (loggedOn == TRUE)
                        if (ZippyControl(buf, &backup) || ZippyConverse(buf, &backup) ||
                           (appData.zippyPlay && ZippyMatch(buf, &backup)));
-       #else
-                if (ZippyControl(buf, &i) ||
-                    ZippyConverse(buf, &i) ||
-                    (appData.zippyPlay && ZippyMatch(buf, &i))) {
-		      loggedOn = TRUE;
-                      if (!appData.colorize) continue;
-		}
-       #endif
 #endif
 	    } // [DM] 'else { ' deleted
 	 	if (
@@ -3428,6 +3499,7 @@ read_from_ics(isr, closure, data, count, error)
 			ZippyGameStart(whitename, blackname);
 		    }
 #endif /*ZIPPY*/
+		    partnerBoardValid = FALSE; // [HGM] bughouse
 		    continue;
 		}
 
@@ -3468,6 +3540,7 @@ read_from_ics(isr, closure, data, count, error)
 		    Reset(TRUE, TRUE);
 		}
 #endif /*ZIPPY*/
+		if(appData.bgObserve && partnerBoardValid) DrawPosition(TRUE, partnerBoard);
 		continue;
 	    }
 
@@ -3564,8 +3637,8 @@ read_from_ics(isr, closure, data, count, error)
 		    if (appData.debugMode)
                       fprintf(debugFP, "Parsing holdings: %s, currentMove = %d\n",
                                                         parse, currentMove);
-		    if (sscanf(parse, " game %d", &gamenum) == 1 &&
-			gamenum == ics_gamenum) {
+		    if (sscanf(parse, " game %d", &gamenum) == 1) {
+		      if(gamenum == ics_gamenum) { // [HGM] bughouse: old code if part of foreground game
 		        if (gameInfo.variant == VariantNormal) {
                           /* [HGM] We seem to switch variant during a game!
                            * Presumably no holdings were displayed, so we have
@@ -3614,9 +3687,22 @@ read_from_ics(isr, closure, data, count, error)
 				    gameInfo.white, white_holding,
 				    gameInfo.black, black_holding);
 			}
-
+			if(!partnerUp) // [HGM] bughouse: when peeking at partner game we already know what he captured...
                         DrawPosition(FALSE, boards[currentMove]);
 			DisplayTitle(str);
+		      } else if(appData.bgObserve) { // [HGM] bughouse: holdings of other game => background
+			sscanf(parse, "game %d white [%s black [%s <- %s",
+			       &gamenum, white_holding, black_holding,
+			       new_piece);
+                        white_holding[strlen(white_holding)-1] = NULLCHAR;
+                        black_holding[strlen(black_holding)-1] = NULLCHAR;
+                        /* [HGM] copy holdings to partner-board holdings area */
+                        CopyHoldings(partnerBoard, white_holding, WhitePawn);
+                        CopyHoldings(partnerBoard, black_holding, BlackPawn);
+                        if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual: always draw
+                        if(partnerUp) DrawPosition(FALSE, partnerBoard);
+                        if(twoBoards) { partnerUp = 0; flipView = !flipView; }
+		      }
 		    }
 		    /* Suppress following prompt */
 		    if (looking_at(buf, &i, "*% ")) {
@@ -3766,6 +3852,38 @@ ParseBoard12(string)
 	break;
     }
     
+    if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)
+	 && newGameMode == IcsObserving && gamenum != ics_gamenum && appData.bgObserve) {
+      // [HGM] bughouse: don't act on alien boards while we play. Just parse the board and save it */
+      char *toSqr;
+      for (k = 0; k < ranks; k++) {
+        for (j = 0; j < files; j++)
+          board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
+        if(gameInfo.holdingsWidth > 1) {
+             board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
+             board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
+        }
+      }
+      CopyBoard(partnerBoard, board);
+      if(toSqr = strchr(str, '/')) { // extract highlights from long move
+        partnerBoard[EP_STATUS-3] = toSqr[1] - AAA; // kludge: hide highlighting info in board
+        partnerBoard[EP_STATUS-4] = toSqr[2] - ONE;
+      } else partnerBoard[EP_STATUS-4] = partnerBoard[EP_STATUS-3] = -1;
+      if(toSqr = strchr(str, '-')) {
+        partnerBoard[EP_STATUS-1] = toSqr[1] - AAA;
+        partnerBoard[EP_STATUS-2] = toSqr[2] - ONE;
+      } else partnerBoard[EP_STATUS-1] = partnerBoard[EP_STATUS-2] = -1;
+      if(appData.dualBoard && !twoBoards) { twoBoards = 1; InitDrawingSizes(-2,0); }
+      if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual
+      if(partnerUp) DrawPosition(FALSE, partnerBoard);
+      if(twoBoards) { partnerUp = 0; flipView = !flipView; } // [HGM] dual
+      sprintf(partnerStatus, "W: %d:%02d B: %d:%02d (%d-%d) %c", white_time/60000, (white_time%60000)/1000,
+		 (black_time/60000), (black_time%60000)/1000, white_stren, black_stren, to_play);
+      DisplayMessage(partnerStatus, "");
+	partnerBoardValid = TRUE;
+      return;
+    }
+
     /* Modify behavior for initial board display on move listing
        of wild games.
        */
@@ -4295,6 +4413,7 @@ ParseBoard12(string)
 	      ClearPremoveHighlights();
 
       j = seekGraphUp; seekGraphUp = FALSE; // [HGM] seekgraph: when we draw a board, it overwrites the seek graph
+	if(partnerUp) { flipView = originalFlip; partnerUp = FALSE; j = TRUE; } // [HGM] bughouse: restore view
       DrawPosition(j, boards[currentMove]);
 
       DisplayMove(moveNum - 1);
@@ -4409,7 +4528,7 @@ SendMoveToProgram(moveNum, cps)
     /*       Send 'go' if we are in a mode where machine should play. */
     if( (moveNum == 0 && setboardSpoiledMachineBlack && cps == &first) &&
         (gameMode == TwoMachinesPlay   ||
-#ifdef ZIPPY
+#if ZIPPY
          gameMode == IcsPlayingBlack     || gameMode == IcsPlayingWhite ||
 #endif
          gameMode == MachinePlaysBlack || gameMode == MachinePlaysWhite) ) {
@@ -4501,6 +4620,73 @@ SendMoveToICS(moveType, fromX, fromY, toX, toY)
 }
 
 void
+UploadGameEvent()
+{   // [HGM] upload: send entire stored game to ICS as long-algebraic moves.
+    int i, last = forwardMostMove; // make sure ICS reply cannot pre-empt us by clearing fmm
+    static char *castlingStrings[4] = { "none", "kside", "qside", "both" };
+    if(gameMode == IcsObserving || gameMode == IcsPlayingBlack || gameMode == IcsPlayingWhite) {
+	DisplayError("You cannot do this while you are playing or observing", 0);
+	return;
+    }
+    if(gameMode != IcsExamining) { // is this ever not the case?
+	char buf[MSG_SIZ], *p, *fen, command[MSG_SIZ], bsetup = 0;
+
+	if(ics_type == ICS_ICC) { // on ICC match ourselves in applicable variant
+	    sprintf(command, "match %s", ics_handle);
+	} else { // on FICS we must first go to general examine mode
+	    strcpy(command, "examine\nbsetup"); // and specify variant within it with bsetups
+	}
+	if(gameInfo.variant != VariantNormal) {
+	    // try figure out wild number, as xboard names are not always valid on ICS
+	    for(i=1; i<=36; i++) {
+		sprintf(buf, "wild/%d", i);
+		if(StringToVariant(buf) == gameInfo.variant) break;
+	    }
+	    if(i<=36 && ics_type == ICS_ICC) sprintf(buf, "%s w%d\n", command, i);
+	    else if(i == 22) sprintf(buf, "%s fr\n", command);
+	    else sprintf(buf, "%s %s\n", command, VariantName(gameInfo.variant));
+	} else sprintf(buf, "%s\n", ics_type == ICS_ICC ? command : "examine\n"); // match yourself or examine
+	SendToICS(ics_prefix);
+	SendToICS(buf);
+	if(startedFromSetupPosition || backwardMostMove != 0) {
+	  fen = PositionToFEN(backwardMostMove, NULL);
+	  if(ics_type == ICS_ICC) { // on ICC we can simply send a complete FEN to set everything
+	    sprintf(buf, "loadfen %s\n", fen);
+	    SendToICS(buf);
+	  } else { // FICS: everything has to set by separate bsetup commands
+	    p = strchr(fen, ' '); p[0] = NULLCHAR; // cut after board
+	    sprintf(buf, "bsetup fen %s\n", fen);
+	    SendToICS(buf);
+	    if(!WhiteOnMove(backwardMostMove)) {
+		SendToICS("bsetup tomove black\n");
+	    }
+	    i = (strchr(p+3, 'K') != NULL) + 2*(strchr(p+3, 'Q') != NULL);
+	    sprintf(buf, "bsetup wcastle %s\n", castlingStrings[i]);
+	    SendToICS(buf);
+	    i = (strchr(p+3, 'k') != NULL) + 2*(strchr(p+3, 'q') != NULL);
+	    sprintf(buf, "bsetup bcastle %s\n", castlingStrings[i]);
+	    SendToICS(buf);
+	    i = boards[backwardMostMove][EP_STATUS];
+	    if(i >= 0) { // set e.p.
+		sprintf(buf, "bsetup eppos %c\n", i+AAA);
+		SendToICS(buf);
+	    }
+	    bsetup++;
+	  }
+	}
+      if(bsetup || ics_type != ICS_ICC && gameInfo.variant != VariantNormal)
+	    SendToICS("bsetup done\n"); // switch to normal examining.
+    }
+    for(i = backwardMostMove; i<last; i++) {
+	char buf[20];
+	sprintf(buf, "%s\n", parseList[i]);
+	SendToICS(buf);
+    }
+    SendToICS(ics_prefix);
+    SendToICS(ics_type == ICS_ICC ? "tag result Game in progress\n" : "commit\n");
+}
+
+void
 CoordsToComputerAlgebraic(rf, ff, rt, ft, promoChar, move)
      int rf, ff, rt, ft;
      char promoChar;
@@ -4584,6 +4770,8 @@ AlphaRank(char *move, int n)
     }
 }
 
+char yy_textstr[8000];
+
 /* Parser for moves from gnuchess, ICS, or user typein box */
 Boolean
 ParseOneMove(move, moveNum, moveType, fromX, fromY, toX, toY, promoChar)
@@ -4596,7 +4784,7 @@ ParseOneMove(move, moveNum, moveType, fromX, fromY, toX, toY, promoChar)
     if (appData.debugMode) {
         fprintf(debugFP, "move to parse: %s\n", move);
     }
-    *moveType = yylexstr(moveNum, move);
+    *moveType = yylexstr(moveNum, move, yy_textstr, sizeof yy_textstr);
 
     switch (*moveType) {
       case WhitePromotionChancellor:
@@ -4685,7 +4873,7 @@ ParseOneMove(move, moveNum, moveType, fromX, fromY, toX, toY, promoChar)
 
 
 void
-ParsePV(char *pv)
+ParsePV(char *pv, Boolean storeComments)
 { // Parse a string of PV moves, and append to current game, behind forwardMostMove
   int fromX, fromY, toX, toY; char promoChar;
   ChessMove moveType;
@@ -4694,18 +4882,36 @@ ParsePV(char *pv)
 
   endPV = forwardMostMove;
   do {
-    while(*pv == ' ') pv++;
-    if(*pv == '(') pv++; // first (ponder) move can be in parentheses
+    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
     valid = ParseOneMove(pv, endPV, &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
 if(appData.debugMode){
-fprintf(debugFP,"parsePV: %d %c%c%c%c '%s'\n", valid, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, pv);
+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);
 }
     if(!valid && nr == 0 &&
        ParseOneMove(pv, endPV-1, &moveType, &fromX, &fromY, &toX, &toY, &promoChar)){ 
         nr++; moveType = Comment; // First move has been played; kludge to make sure we continue
+        // Hande case where played move is different from leading PV move
+        CopyBoard(boards[endPV+1], boards[endPV-1]); // tentatively unplay last game move
+        CopyBoard(boards[endPV+2], boards[endPV-1]); // and play first move of PV
+        ApplyMove(fromX, fromY, toX, toY, promoChar, boards[endPV+2]);
+        if(!CompareBoards(boards[endPV], boards[endPV+2])) {
+          endPV += 2; // if position different, keep this
+          moveList[endPV-1][0] = fromX + AAA;
+          moveList[endPV-1][1] = fromY + ONE;
+          moveList[endPV-1][2] = toX + AAA;
+          moveList[endPV-1][3] = toY + ONE;
+          parseList[endPV-1][0] = NULLCHAR;
+          strcpy(moveList[endPV-2], "_0_0"); // suppress premove highlight on takeback move
+        }
+      }
+    pv = strstr(pv, yy_textstr) + strlen(yy_textstr); // skip what we parsed
+    if(nr == 0 && !storeComments && *pv == ')') pv++; // closing parenthesis of ponder move;
+    if(moveType == Comment && storeComments) AppendComment(endPV, yy_textstr, FALSE);
+    if(moveType == Comment || moveType == NAG || moveType == ElapsedTime) {
+	valid++; // allow comments in PV
+	continue;
     }
-    while(*pv && *pv++ != ' '); // skip what we parsed; assume space separators
-    if(moveType == Comment) { valid++; continue; } // allow comments in PV
     nr++;
     if(endPV+1 > framePtr) break; // no space, truncate
     if(!valid) break;
@@ -4716,7 +4922,13 @@ fprintf(debugFP,"parsePV: %d %c%c%c%c '%s'\n", valid, fromX+AAA, fromY+ONE, toX+
     moveList[endPV-1][1] = fromY + ONE;
     moveList[endPV-1][2] = toX + AAA;
     moveList[endPV-1][3] = toY + ONE;
-    parseList[endPV-1][0] = NULLCHAR;
+    if(storeComments)
+	CoordsToAlgebraic(boards[endPV - 1],
+			     PosFlags(endPV - 1),
+			     fromY, fromX, toY, toX, promoChar,
+			     parseList[endPV - 1]);
+    else
+	parseList[endPV-1][0] = NULLCHAR;
   } while(valid);
   currentMove = endPV;
   if(currentMove == forwardMostMove) ClearPremoveHighlights(); else
@@ -4731,16 +4943,19 @@ Boolean
 LoadMultiPV(int x, int y, char *buf, int index, int *start, int *end)
 {
 	int startPV;
+	char *p;
 
 	if(index < 0 || index >= strlen(buf)) return FALSE; // sanity
 	lastX = x; lastY = y;
 	while(index > 0 && buf[index-1] != '\n') index--; // beginning of line
 	startPV = index;
-      while(buf[index] != '\n') if(buf[index++] == '\t') startPV = index;
-      index = startPV;
-	while(buf[index] && buf[index] != '\n') index++;
+	while(buf[index] != '\n') if(buf[index++] == '\t') startPV = index;
+	if(index == startPV && (p = StrCaseStr(buf+index, "PV="))) startPV = p - buf + 3;
+	index = startPV;
+	do{ while(buf[index] && buf[index] != '\n') index++;
+	} while(buf[index] == '\n' && buf[index+1] == '\\' && buf[index+2] == ' ' && index++); // join kibitzed PV continuation line
 	buf[index] = 0;
-	ParsePV(buf+startPV);
+	ParsePV(buf+startPV, FALSE);
 	*start = startPV; *end = index-1;
 	return TRUE;
 }
@@ -4750,7 +4965,7 @@ LoadPV(int x, int y)
 { // called on right mouse click to load PV
   int which = gameMode == TwoMachinesPlay && (WhiteOnMove(forwardMostMove) == (second.twoMachinesColor[0] == 'w'));
   lastX = x; lastY = y;
-  ParsePV(lastPV[which]); // load the PV of the thinking engine in the boards array.
+  ParsePV(lastPV[which], FALSE); // load the PV of the thinking engine in the boards array.
   return TRUE;
 }
 
@@ -5043,7 +5258,10 @@ InitPosition(redraw)
     for(i=0; i<BOARD_FILES-2; i++)
       initialPosition[CASTLING][i] = initialRights[i] = NoRights; /* but no rights yet */
     initialPosition[EP_STATUS] = EP_NONE;
-    SetCharTable(pieceToChar, "PNBRQ...........Kpnbrq...........k"); 
+    SetCharTable(pieceToChar, "PNBRQ...........Kpnbrq...........k");
+    if(startVariant == gameInfo.variant) // [HGM] nicks: enable nicknames in original variant
+         SetCharTable(pieceNickName, appData.pieceNickNames);
+    else SetCharTable(pieceNickName, "............");
 
     switch (gameInfo.variant) {
     case VariantFischeRandom:
@@ -6049,7 +6267,7 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 {
     int x, y;
     Boolean saveAnimate;
-    static int second = 0, promotionChoice = 0;
+    static int second = 0, promotionChoice = 0, dragging = 0;
     char promoChoice = NULLCHAR;
 
     if(appData.seekGraph && appData.icsActive && loggedOn &&
@@ -6109,11 +6327,14 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 		fromY = y;
 		second = 0;
 		MarkTargetSquares(0);
-		DragPieceBegin(xPix, yPix);
+		DragPieceBegin(xPix, yPix); dragging = 1;
 		if (appData.highlightDragging) {
 		    SetHighlights(x, y, -1, -1);
 		}
 	    }
+	} else if(dragging) { // [HGM] from-square must have been reset due to game end since last press
+	    DragPieceEnd(xPix, yPix); dragging = 0;
+	    DrawPosition(FALSE, NULL);
 	}
 	return;
       }
@@ -6142,7 +6363,7 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 	     !(fromP == BlackKing && toP == BlackRook && frc))) {
 	    /* Clicked again on same color piece -- changed his mind */
 	    second = (x == fromX && y == fromY);
-	   if(!second || !OnlyMove(&x, &y, TRUE)) {
+	   if(!second || appData.oneClick && !OnlyMove(&x, &y, TRUE)) {
 	    if (appData.highlightDragging) {
 		SetHighlights(x, y, -1, -1);
 	    } else {
@@ -6150,7 +6371,7 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 	    }
 	    if (OKToStartUserMove(x, y)) {
 		fromX = x;
-		fromY = y;
+		fromY = y; dragging = 1;
 		MarkTargetSquares(0);
 		DragPieceBegin(xPix, yPix);
 	    }
@@ -6162,7 +6383,7 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
     }
 
     if (clickType == Release && x == fromX && y == fromY) {
-	DragPieceEnd(xPix, yPix);
+	DragPieceEnd(xPix, yPix); dragging = 0;
 	if (appData.animateDragging) {
 	    /* Undo animation damage if any */
 	    DrawPosition(FALSE, NULL);
@@ -6200,7 +6421,7 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 	} else {
 	    ClearHighlights();
 	}
-	DragPieceEnd(xPix, yPix);
+	DragPieceEnd(xPix, yPix); dragging = 0;
 	/* Don't animate move and drag both */
 	appData.animate = FALSE;
     }
@@ -6274,6 +6495,24 @@ int RightClick(ClickType action, int x, int y, int *fromX, int *fromY)
 	return -2;
     }
 
+    if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)
+	 && !appData.zippyPlay && appData.bgObserve) { // [HGM] bughouse: show background game
+	if(!partnerBoardValid) return -2; // suppress display of uninitialized boards
+	if( appData.dualBoard) return -2; // [HGM] dual: is already displayed
+	if(action == Press)   {
+	    originalFlip = flipView;
+	    flipView = !flipView; // temporarily flip board to see game from partners perspective
+	    DrawPosition(TRUE, partnerBoard);
+	    DisplayMessage(partnerStatus, "");
+	    partnerUp = TRUE;
+	} else if(action == Release) {
+	    flipView = originalFlip;
+	    DrawPosition(TRUE, boards[currentMove]);
+	    partnerUp = FALSE;
+	}
+	return -2;
+    }
+
     xSqr = EventToSquare(x, BOARD_WIDTH);
     ySqr = EventToSquare(y, BOARD_HEIGHT);
     if (action == Release) UnLoadPV(); // [HGM] pv
@@ -6353,6 +6592,103 @@ void SendProgramStatsToFrontend( ChessProgramState * cps, ChessProgramStats * cp
     SetProgramStats( &stats );
 }
 
+void
+Count(Board board, int pCnt[], int *nW, int *nB, int *wStale, int *bStale, int *bishopColor)
+{	// count all piece types
+	int p, f, r;
+	*nB = *nW = *wStale = *bStale = *bishopColor = 0;
+	for(p=WhitePawn; p<=EmptySquare; p++) pCnt[p] = 0;
+	for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
+		p = board[r][f];
+		pCnt[p]++;
+		if(p == WhitePawn && r == BOARD_HEIGHT-1) (*wStale)++; else
+		if(p == BlackPawn && r == 0) (*bStale)++; // count last-Rank Pawns (XQ) separately
+		if(p <= WhiteKing) (*nW)++; else if(p <= BlackKing) (*nB)++;
+		if(p == WhiteBishop || p == WhiteFerz || p == WhiteAlfil ||
+		   p == BlackBishop || p == BlackFerz || p == BlackAlfil   )
+			*bishopColor |= 1 << ((f^r)&1); // track square color of color-bound pieces
+	}
+}
+
+int
+SufficientDefence(int pCnt[], int side, int nMine, int nHis)
+{
+	int myPawns = pCnt[WhitePawn+side]; // my total Pawn count;
+	int majorDefense = pCnt[BlackRook-side] + pCnt[BlackCannon-side] + pCnt[BlackKnight-side];
+		   
+	nMine -= pCnt[WhiteFerz+side] + pCnt[WhiteAlfil+side]; // discount defenders
+	if(nMine - myPawns > 2) return FALSE; // no trivial draws with more than 1 major
+	if(myPawns == 2 && nMine == 3) // KPP
+	    return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] >= 3;
+	if(myPawns == 1 && nMine == 2) // KP
+	    return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side]  + pCnt[BlackPawn-side] >= 1;
+	if(myPawns == 1 && nMine == 3 && pCnt[WhiteKnight+side]) // KHP
+	    return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side]*2 >= 5;
+	if(myPawns) return FALSE;
+	if(pCnt[WhiteRook+side])
+	    return pCnt[BlackRook-side] || 
+		   pCnt[BlackCannon-side] && (pCnt[BlackFerz-side] >= 2 || pCnt[BlackAlfil-side] >= 2) ||
+		   pCnt[BlackKnight-side] && pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] > 2 ||
+		   pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] >= 4;
+	if(pCnt[WhiteCannon+side]) {
+	    if(pCnt[WhiteFerz+side] + myPawns == 0) return TRUE; // Cannon needs platform
+	    return majorDefense || pCnt[BlackAlfil-side] >= 2;
+	}
+	if(pCnt[WhiteKnight+side])
+	    return majorDefense || pCnt[BlackFerz-side] >= 2 || pCnt[BlackAlfil-side] + pCnt[BlackPawn-side] >= 1;
+	return FALSE;
+}
+
+int
+MatingPotential(int pCnt[], int side, int nMine, int nHis, int stale, int bisColor)
+{
+	VariantClass v = gameInfo.variant;
+
+	if(v == VariantShogi || v == VariantCrazyhouse || v == VariantBughouse) return TRUE; // drop games always winnable
+	if(v == VariantShatranj) return TRUE; // always winnable through baring
+	if(v == VariantLosers || v == VariantSuicide || v == VariantGiveaway) return TRUE;
+	if(v == Variant3Check || v == VariantAtomic) return nMine > 1; // can win through checking / exploding King
+
+	if(v == VariantXiangqi) {
+		int majors = 5*pCnt[BlackKnight-side] + 7*pCnt[BlackCannon-side] + 7*pCnt[BlackRook-side];
+
+		nMine -= pCnt[WhiteFerz+side] + pCnt[WhiteAlfil+side] + stale; // discount defensive pieces and back-rank Pawns
+		if(nMine + stale == 1) return (pCnt[BlackFerz-side] > 1 && pCnt[BlackKnight-side] > 0); // bare K can stalemate KHAA (!)
+		if(nMine > 2) return TRUE; // if we don't have P, H or R, we must have CC
+		if(nMine == 2 && pCnt[WhiteCannon+side] == 0) return TRUE; // We have at least one P, H or R
+		// if we get here, we must have KC... or KP..., possibly with additional A, E or last-rank P
+		if(stale) // we have at least one last-rank P plus perhaps C
+		    return majors // KPKX
+		        || pCnt[BlackFerz-side] && pCnt[BlackFerz-side] + pCnt[WhiteCannon+side] + stale > 2; // KPKAA, KPPKA and KCPKA
+		else // KCA*E*
+		    return pCnt[WhiteFerz+side] // KCAK
+		        || pCnt[WhiteAlfil+side] && pCnt[BlackRook-side] + pCnt[BlackCannon-side] + pCnt[BlackFerz-side] // KCEKA, KCEKX (X!=H)
+		        || majors + (12*pCnt[BlackFerz-side] | 6*pCnt[BlackAlfil-side]) > 16; // KCKAA, KCKAX, KCKEEX, KCKEXX (XX!=HH), KCKXXX
+		// TO DO: cases wih an unpromoted f-Pawn acting as platform for an opponent Cannon
+
+	} else if(pCnt[WhiteKing] == 1 && pCnt[BlackKing] == 1) { // other variants with orthodox Kings
+		int nBishops = pCnt[WhiteBishop+side] + pCnt[WhiteFerz+side];
+		
+		if(nMine == 1) return FALSE; // bare King
+		if(nBishops && bisColor == 3) return TRUE; // There must be a second B/A/F, which can either block (his) or attack (mine) the escape square
+		nMine += (nBishops > 0) - nBishops; // By now all Bishops (and Ferz) on like-colored squares, so count as one
+		if(nMine > 2 && nMine != pCnt[WhiteAlfil+side] + 1) return TRUE; // At least two pieces, not all Alfils
+		// by now we have King + 1 piece (or multiple Bishops on the same color)
+		if(pCnt[WhiteKnight+side])
+			return (pCnt[BlackKnight-side] + pCnt[BlackBishop-side] + pCnt[BlackMan-side] + 
+				pCnt[BlackWazir-side] + pCnt[BlackSilver-side] + bisColor // KNKN, KNKB, KNKF, KNKE, KNKW, KNKM, KNKS
+			     || nHis > 3); // be sure to cover suffocation mates in corner (e.g. KNKQCA)
+		if(nBishops)
+			return (pCnt[BlackKnight-side]); // KBKN, KFKN
+		if(pCnt[WhiteAlfil+side])
+			return (nHis > 2); // Alfils can in general not reach a corner square, but there might be edge (suffocation) mates
+		if(pCnt[WhiteWazir+side])
+			return (pCnt[BlackKnight-side] + pCnt[BlackWazir-side] + pCnt[BlackAlfil-side]); // KWKN, KWKW, KWKE
+	}
+
+	return TRUE;
+}
+
 int
 Adjudicate(ChessProgramState *cps)
 {	// [HGM] some adjudications useful with buggy engines
@@ -6368,61 +6704,16 @@ Adjudicate(ChessProgramState *cps)
 	if(gameInfo.holdingsSize == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
 	    if( appData.testLegality )
 	    {   /* [HGM] Some more adjudications for obstinate engines */
-		int NrWN=0, NrBN=0, NrWB=0, NrBB=0, NrWR=0, NrBR=0,
-                    NrWQ=0, NrBQ=0, NrW=0, NrK=0, bishopsColor = 0,
-                    NrPieces=0, NrPawns=0, PawnAdvance=0, i, j;
+		int nrW, nrB, bishopColor, staleW, staleB, nr[EmptySquare+1], i;
 		static int moveCount = 6;
 		ChessMove result;
 		char *reason = NULL;
 
                 /* Count what is on board. */
-		for(i=0; i<BOARD_HEIGHT; i++) for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
-		{   ChessSquare p = boards[forwardMostMove][i][j];
-		    int m=i;
-
-		    switch((int) p)
-		    {   /* count B,N,R and other of each side */
-                        case WhiteKing:
-                        case BlackKing:
-			     NrK++; break; // [HGM] atomic: count Kings
-                        case WhiteKnight:
-                             NrWN++; break;
-                        case WhiteBishop:
-                        case WhiteFerz:    // [HGM] shatranj: kludge to mke it work in shatranj
-                             bishopsColor |= 1 << ((i^j)&1);
-                             NrWB++; break;
-                        case BlackKnight:
-                             NrBN++; break;
-                        case BlackBishop:
-                        case BlackFerz:    // [HGM] shatranj: kludge to mke it work in shatranj
-                             bishopsColor |= 1 << ((i^j)&1);
-                             NrBB++; break;
-                        case WhiteRook:
-                             NrWR++; break;
-                        case BlackRook:
-                             NrBR++; break;
-                        case WhiteQueen:
-                             NrWQ++; break;
-                        case BlackQueen:
-                             NrBQ++; break;
-                        case EmptySquare: 
-                             break;
-                        case BlackPawn:
-                             m = 7-i;
-                        case WhitePawn:
-                             PawnAdvance += m; NrPawns++;
-                    }
-                    NrPieces += (p != EmptySquare);
-                    NrW += ((int)p < (int)BlackPawn);
-		    if(gameInfo.variant == VariantXiangqi && 
-		      (p == WhiteFerz || p == WhiteAlfil || p == BlackFerz || p == BlackAlfil)) {
-			NrPieces--; // [HGM] XQ: do not count purely defensive pieces
-                        NrW -= ((int)p < (int)BlackPawn);
-		    }
-                }
+		Count(boards[forwardMostMove], nr, &nrW, &nrB, &staleW, &staleB, &bishopColor);
 
 		/* Some material-based adjudications that have to be made before stalemate test */
-		if(gameInfo.variant == VariantAtomic && NrK < 2) {
+		if(gameInfo.variant == VariantAtomic && nr[WhiteKing] + nr[BlackKing] < 2) {
 		    // [HGM] atomic: stm must have lost his King on previous move, as destroying own K is illegal
 		     boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // make claimable as if stm is checkmated
 		     if(canAdjudicate && appData.checkMates) {
@@ -6436,7 +6727,7 @@ Adjudicate(ChessProgramState *cps)
 		}
 
 		/* Bare King in Shatranj (loses) or Losers (wins) */
-                if( NrW == 1 || NrPieces - NrW == 1) {
+                if( nrW == 1 || nrB == 1) {
                   if( gameInfo.variant == VariantLosers) { // [HGM] losers: bare King wins (stm must have it first)
 		     boards[forwardMostMove][EP_STATUS] = EP_WINS;  // mark as win, so it becomes claimable
 		     if(canAdjudicate && appData.checkMates) {
@@ -6456,7 +6747,7 @@ Adjudicate(ChessProgramState *cps)
 			    if(engineOpponent)
 			      SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
 			    ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
-			    GameEnds( NrW > 1 ? WhiteWins : NrPieces - NrW > 1 ? BlackWins : GameIsDrawn, 
+			    GameEnds( nrW > 1 ? WhiteWins : nrB > 1 ? BlackWins : GameIsDrawn, 
 							"Xboard adjudication: Bare king", GE_XBOARD );
 			    return 1;
 			}
@@ -6490,8 +6781,8 @@ Adjudicate(ChessProgramState *cps)
 		    if(gameInfo.variant == VariantLosers  || gameInfo.variant == VariantGiveaway) // [HGM] losers:
 			boards[forwardMostMove][EP_STATUS] = EP_WINS;    // in these variants stalemated is always a win
 		    else if(gameInfo.variant == VariantSuicide) // in suicide it depends
-			boards[forwardMostMove][EP_STATUS] = NrW == NrPieces-NrW ? EP_STALEMATE :
-						   ((NrW < NrPieces-NrW) != WhiteOnMove(forwardMostMove) ?
+			boards[forwardMostMove][EP_STATUS] = nrW == nrB ? EP_STALEMATE :
+						   ((nrW < nrB) != WhiteOnMove(forwardMostMove) ?
 									EP_CHECKMATE : EP_WINS);
 		    else if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantXiangqi)
 		        boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // and in these variants being stalemated loses
@@ -6522,11 +6813,9 @@ Adjudicate(ChessProgramState *cps)
 		}
 
                 /* Next absolutely insufficient mating material. */
-                if( NrPieces == 2 || gameInfo.variant != VariantXiangqi && 
-				     gameInfo.variant != VariantShatranj && // [HGM] baring will remain possible
-			(NrPieces == 3 && NrWN+NrBN+NrWB+NrBB == 1 ||
-			 NrPieces == NrBB+NrWB+2 && bishopsColor != 3)) // [HGM] all Bishops (Ferz!) same color
-                {    /* KBK, KNK, KK of KBKB with like Bishops */
+                if(!MatingPotential(nr, WhitePawn, nrW, nrB, staleW, bishopColor) &&
+                   !MatingPotential(nr, BlackPawn, nrB, nrW, staleB, bishopColor))
+                {    /* includes KBK, KNK, KK of KBKB with like Bishops */
 
                      /* always flag draws, for judging claims */
                      boards[forwardMostMove][EP_STATUS] = EP_INSUF_DRAW;
@@ -6544,13 +6833,15 @@ Adjudicate(ChessProgramState *cps)
                 }
 
                 /* Then some trivial draws (only adjudicate, cannot be claimed) */
-                if(NrPieces == 4 && 
-                   (   NrWR == 1 && NrBR == 1 /* KRKR */
-                   || NrWQ==1 && NrBQ==1     /* KQKQ */
-                   || NrWN==2 || NrBN==2     /* KNNK */
-                   || NrWN+NrWB == 1 && NrBN+NrBB == 1 /* KBKN, KBKB, KNKN */
-                  ) ) {
-                     if(canAdjudicate && --moveCount < 0 && appData.trivialDraws)
+                if(gameInfo.variant == VariantXiangqi ?
+                       SufficientDefence(nr, WhitePawn, nrW, nrB) && SufficientDefence(nr, BlackPawn, nrB, nrW)
+                 : nrW + nrB == 4 && 
+                   (   nr[WhiteRook] == 1 && nr[BlackRook] == 1 /* KRKR */
+                   || nr[WhiteQueen] && nr[BlackQueen]==1     /* KQKQ */
+                   || nr[WhiteKnight]==2 || nr[BlackKnight]==2     /* KNNK */
+                   || nr[WhiteKnight]+nr[WhiteBishop] == 1 && nr[BlackKnight]+nr[BlackBishop] == 1 /* KBKN, KBKB, KNKN */
+                   ) ) {
+                     if(--moveCount < 0 && appData.trivialDraws && canAdjudicate)
                      {    /* if the first 3 moves do not show a tactical win, declare draw */
 			  if(engineOpponent) {
 			    SendToProgram("force\n", engineOpponent); // suppress reply
@@ -6601,14 +6892,11 @@ Adjudicate(ChessProgramState *cps)
                                 boards[forwardMostMove][CASTLING][4] != boards[k][CASTLING][4] )
                                    rights++;
                         }
-                        if( canAdjudicate && rights == 0 && ++count > appData.drawRepeats-2
+                        if( rights == 0 && ++count > appData.drawRepeats-2 && canAdjudicate
                             && appData.drawRepeats > 1) {
                              /* adjudicate after user-specified nr of repeats */
-			     if(engineOpponent) {
-			       SendToProgram("force\n", engineOpponent); // suppress reply
-			       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
-			     }
-                             ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
+			     int result = GameIsDrawn;
+			     char *details = "XBoard adjudication: repetition draw";
 			     if(gameInfo.variant == VariantXiangqi && appData.testLegality) { 
 				// [HGM] xiangqi: check for forbidden perpetuals
 				int m, ourPerpetual = 1, hisPerpetual = 1;
@@ -6621,27 +6909,31 @@ Adjudicate(ChessProgramState *cps)
 				if(appData.debugMode) fprintf(debugFP, "XQ perpetual test, our=%d, his=%d\n",
 									ourPerpetual, hisPerpetual);
 				if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit
-				    GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins, 
-		 			   "Xboard adjudication: perpetual checking", GE_XBOARD );
-				    return 1;
-				}
-				if(hisPerpetual && !ourPerpetual)   // he is checking us, but did not repeat yet
+				    result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
+		 		    details = "Xboard adjudication: perpetual checking";
+				} else
+				if(hisPerpetual && !ourPerpetual) { // he is checking us, but did not repeat yet
 				    break; // (or we would have caught him before). Abort repetition-checking loop.
+				} else
 				// Now check for perpetual chases
 				if(!ourPerpetual && !hisPerpetual) { // no perpetual check, test for chase
 				    hisPerpetual = PerpetualChase(k, forwardMostMove);
 				    ourPerpetual = PerpetualChase(k+1, forwardMostMove);
 				    if(ourPerpetual && !hisPerpetual) { // we are actively chasing him: forfeit
-					GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins, 
-		 				      "Xboard adjudication: perpetual chasing", GE_XBOARD );
-					return 1;
-				    }
+					result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
+		 			details = "Xboard adjudication: perpetual chasing";
+				    } else
 				    if(hisPerpetual && !ourPerpetual)   // he is chasing us, but did not repeat yet
 					break; // Abort repetition-checking loop.
 				}
 				// if neither of us is checking or chasing all the time, or both are, it is draw
 			     }
-                             GameEnds( GameIsDrawn, "Xboard adjudication: repetition draw", GE_XBOARD );
+			     if(engineOpponent) {
+			       SendToProgram("force\n", engineOpponent); // suppress reply
+			       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
+			     }
+                             ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
+                             GameEnds( result, details, GE_XBOARD );
                              return 1;
                         }
                         if( rights == 0 && count > 1 ) /* occurred 2 or more times before */
@@ -6658,6 +6950,17 @@ Adjudicate(ChessProgramState *cps)
                 if( count == backwardMostMove )
                     count -= initialRulePlies;
                 count = forwardMostMove - count; 
+		if(gameInfo.variant == VariantXiangqi && ( count >= 100 || count >= 2*appData.ruleMoves ) ) {
+			// adjust reversible move counter for checks in Xiangqi
+			int i = forwardMostMove - count, inCheck = 0, lastCheck;
+			if(i < backwardMostMove) i = backwardMostMove;
+			while(i <= forwardMostMove) {
+				lastCheck = inCheck; // check evasion does not count
+				inCheck = (MateTest(boards[i], PosFlags(i)) == MT_CHECK);
+				if(inCheck || lastCheck) count--; // check does not count
+				i++;
+			}
+		}
                 if( count >= 100)
                          boards[forwardMostMove][EP_STATUS] = EP_RULE_DRAW;
                          /* this is used to judge if draw claims are legal */
@@ -6726,8 +7029,7 @@ char *SendMoveToBookUser(int moveNr, ChessProgramState *cps, int initial)
 	// 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];
-	if (cps->useUsermove) sprintf(buf, "usermove "); // sorry, no SAN yet :(
-	sprintf(buf, "%s\n", bookHit); // force book move into program supposed to play it
+	sprintf(buf, "%s%s\n", (cps->useUsermove ? "usermove " : ""), bookHit); // 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
@@ -6944,6 +7246,11 @@ FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book h
 	strcat(machineMove, "\n");
 	strcpy(moveList[forwardMostMove], machineMove);
 
+        /* [AS] Save move info*/
+        pvInfoList[ forwardMostMove ].score = programStats.score;
+        pvInfoList[ forwardMostMove ].depth = programStats.depth;
+        pvInfoList[ forwardMostMove ].time =  programStats.time; // [HGM] PGNtime: take time from engine stats
+
 	MakeMove(fromX, fromY, toX, toY, promoChar);/*updates forwardMostMove*/
 
         /* [AS] Adjudicate game if needed (note: remember that forwardMostMove now points past the last move) */
@@ -7003,10 +7310,7 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
 	}
 #endif
 
-        /* [AS] Save move info and clear stats for next move */
-        pvInfoList[ forwardMostMove-1 ].score = programStats.score;
-        pvInfoList[ forwardMostMove-1 ].depth = programStats.depth;
-        pvInfoList[ forwardMostMove-1 ].time =  programStats.time; // [HGM] PGNtime: take time from engine stats
+        /* [AS] Clear stats for next move */
         ClearProgramStats();
         thinkOutput[0] = NULLCHAR;
         hiddenThinkOutputState = 0;
@@ -7112,11 +7416,13 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
      * Look for communication commands
      */
     if (!strncmp(message, "telluser ", 9)) {
+	EscapeExpand(message+9, message+9); // [HGM] esc: allow escape sequences in popup box
 	DisplayNote(message + 9);
 	return;
     }
     if (!strncmp(message, "tellusererror ", 14)) {
 	cps->userError = 1;
+	EscapeExpand(message+14, message+14); // [HGM] esc: allow escape sequences in popup box
 	DisplayError(message + 14, 0);
 	return;
     }
@@ -7570,6 +7876,7 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
 	}
 
 	if (!ignore) {
+	    ChessProgramStats tempStats = programStats; // [HGM] info: filter out info lines
 	    buf1[0] = NULLCHAR;
 	    if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
 		       &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5) {
@@ -7591,11 +7898,11 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
                 }
 
 
-		programStats.depth = plylev;
-		programStats.nodes = nodes;
-		programStats.time = time;
-		programStats.score = curscore;
-		programStats.got_only_move = 0;
+		tempStats.depth = plylev;
+		tempStats.nodes = nodes;
+		tempStats.time = time;
+		tempStats.score = curscore;
+		tempStats.got_only_move = 0;
 
 		if(cps->nps >= 0) { /* [HGM] nps: use engine nodes or time to decrement clock */
 			int ticklen;
@@ -7612,31 +7919,34 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
 
 		/* Buffer overflow protection */
 		if (buf1[0] != NULLCHAR) {
-		    if (strlen(buf1) >= sizeof(programStats.movelist)
+		    if (strlen(buf1) >= sizeof(tempStats.movelist)
 			&& appData.debugMode) {
 			fprintf(debugFP,
 				"PV is too long; using the first %u bytes.\n",
-				(unsigned) sizeof(programStats.movelist) - 1);
+				(unsigned) sizeof(tempStats.movelist) - 1);
 		    }
 
-                    safeStrCpy( programStats.movelist, buf1, sizeof(programStats.movelist) );
+                    safeStrCpy( tempStats.movelist, buf1, sizeof(tempStats.movelist) );
 		} else {
-		    sprintf(programStats.movelist, " no PV\n");
+		    sprintf(tempStats.movelist, " no PV\n");
 		}
 
-		if (programStats.seen_stat) {
-		    programStats.ok_to_send = 1;
+		if (tempStats.seen_stat) {
+		    tempStats.ok_to_send = 1;
 		}
 
-		if (strchr(programStats.movelist, '(') != NULL) {
-		    programStats.line_is_book = 1;
-		    programStats.nr_moves = 0;
-		    programStats.moves_left = 0;
+		if (strchr(tempStats.movelist, '(') != NULL) {
+		    tempStats.line_is_book = 1;
+		    tempStats.nr_moves = 0;
+		    tempStats.moves_left = 0;
 		} else {
-		    programStats.line_is_book = 0;
+		    tempStats.line_is_book = 0;
 		}
 
-                SendProgramStatsToFrontend( cps, &programStats );
+		    if(tempStats.score != 0 || tempStats.nodes != 0 || tempStats.time != 0)
+			programStats = tempStats; // [HGM] info: only set stats if genuine PV and not an info line
+
+                SendProgramStatsToFrontend( cps, &tempStats );
 
                 /* 
                     [AS] Protect the thinkOutput buffer from overflow... this
@@ -8335,7 +8645,7 @@ MakeMove(fromX, fromY, toX, toY, promoChar)
         if( (boards[forwardMostMove][fromY][fromX] == WhitePawn ||
              boards[forwardMostMove][fromY][fromX] == BlackPawn   ) &&
              boards[forwardMostMove][toY][toX] == EmptySquare
-             && fromX != toX )
+             && fromX != toX && fromY != toY)
                 fprintf(serverMoves, ":%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+fromY);
         // promotion suffix
         if(promoChar != NULLCHAR)
@@ -8711,11 +9021,14 @@ GameEnds(result, resultDetails, whosays)
 {
     GameMode nextGameMode;
     int isIcsGame;
-    char buf[MSG_SIZ];
+    char buf[MSG_SIZ], popupRequested = 0;
 
     if(endingGame) return; /* [HGM] crash: forbid recursion */
     endingGame = 1;
-
+    if(twoBoards) { // [HGM] dual: switch back to one board
+	twoBoards = partnerUp = 0; InitDrawingSizes(-2, 0);
+	DrawPosition(TRUE, partnerBoard); // observed game becomes foreground
+    }
     if (appData.debugMode) {
       fprintf(debugFP, "GameEnds(%d, %s, %d)\n",
 	      result, resultDetails ? resultDetails : "(null)", whosays);
@@ -9044,13 +9357,12 @@ GameEnds(result, resultDetails, whosays)
 	    endingGame = 0; /* [HGM] crash */
 	    return;
 	} else {
-	    char buf[MSG_SIZ];
 	    gameMode = nextGameMode;
 	    sprintf(buf, _("Match %s vs. %s: final score %d-%d-%d"),
 		    first.tidy, second.tidy,
 		    first.matchWins, second.matchWins,
 		    appData.matchGames - (first.matchWins + second.matchWins));
-	    DisplayFatalError(buf, 0, 0);
+	    popupRequested++; // [HGM] crash: postpone to after resetting endingGame
 	}
     }
     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile) &&
@@ -9059,6 +9371,12 @@ GameEnds(result, resultDetails, whosays)
     gameMode = nextGameMode;
     ModeHighlight();
     endingGame = 0;  /* [HGM] crash */
+    if(popupRequested) { // [HGM] crash: this calls GameEnds recursively through ExitEvent! Make it a harmless tail recursion.
+      if(matchMode == TRUE) DisplayFatalError(buf, 0, 0); else {
+	matchMode = FALSE; appData.matchGames = matchGame = 0;
+	DisplayNote(buf);
+      }
+    }
 }
 
 /* Assumes program was just initialized (initString sent).
@@ -9923,6 +10241,7 @@ LoadGame(f, gameNumber, title, useList)
         /* [HGM] PGNvariant: automatically switch to variant given in PGN tag */
         if(gameInfo.variant != oldVariant) {
             startedFromPositionFile = FALSE; /* [HGM] loadPos: variant switch likely makes position invalid */
+	    ResetFrontEnd(); // [HGM] might need other bitmaps. Cannot use Reset() because it clears gameInfo :-(
 	    InitPosition(TRUE);
             oldVariant = gameInfo.variant;
 	    if (appData.debugMode) 
@@ -9985,7 +10304,9 @@ LoadGame(f, gameNumber, title, useList)
     if (numPGNTags > 0){
         char *tags;
 	if (gameInfo.variant == VariantNormal) {
-	  gameInfo.variant = StringToVariant(gameInfo.event);
+	  VariantClass v = StringToVariant(gameInfo.event);
+	  // [HGM] do not recognize variants from event tag that were introduced after supporting variant tag
+	  if(v < VariantShogi) gameInfo.variant = v;
 	}
 	if (!matchMode) {
           if( appData.autoDisplayTags ) {
@@ -12515,9 +12836,9 @@ ToNrEvent(int to)
 }
 
 void
-RevertEvent()
+RevertEvent(Boolean annotate)
 {
-    if(PopTail(TRUE)) { // [HGM] vari: restore old game tail
+    if(PopTail(annotate)) { // [HGM] vari: restore old game tail
 	return;
     }
     if (gameMode != IcsExamining) {
@@ -13172,8 +13493,10 @@ ReceiveFromProgram(isr, closure, message, count, error)
 		   sscanf(message, "error %c", &c)!=1 && sscanf(message, "illegal %c", &c)!=1 &&
 		   sscanf(message, "tell%c", &c)!=1   && sscanf(message, "0-1 %c", &c)!=1 &&
 		   sscanf(message, "1-0 %c", &c)!=1   && sscanf(message, "1/2-1/2 %c", &c)!=1 &&
-		   sscanf(message, "pong %c", &c)!=1   && start != '#')
-			{ quote = "# "; print = (appData.engineComments == 2); }
+		   sscanf(message, "pong %c", &c)!=1   && start != '#')	{
+		    quote = appData.engineComments == 2 ? "# " : "### NON-COMPLIANT! ### ";
+		    print = (appData.engineComments >= 2);
+		}
 		message[0] = start; // restore original message
 	}
 	if(print) {
@@ -13534,7 +13857,6 @@ ParseFeatures(args, cps)
 	}
 	continue;
     }
-    if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
     /* End of additions by HGM */
 
     /* unknown feature: complain and skip */
@@ -13598,17 +13920,17 @@ PonderNextMoveEvent(newState)
 }
 
 void
-NewSettingEvent(option, command, value)
+NewSettingEvent(option, feature, command, value)
      char *command;
-     int option, value;
+     int option, value, *feature;
 {
     char buf[MSG_SIZ];
 
     if (gameMode == EditPosition) EditPositionDone(TRUE);
     sprintf(buf, "%s%s %d\n", (option ? "option ": ""), command, value);
-    SendToProgram(buf, &first);
+    if(feature == NULL || *feature) SendToProgram(buf, &first);
     if (gameMode == TwoMachinesPlay) {
-	SendToProgram(buf, &second);
+	if(feature == NULL || feature[(int*)&second - (int*)&first]) SendToProgram(buf, &second);
     }
 }
 
@@ -13690,7 +14012,7 @@ DisplayMove(moveNumber)
 	    sprintf(res, " %s", PGNResult(gameInfo.result));
 	} else {
 	    sprintf(res, " {%s} %s",
-		    gameInfo.resultDetails, PGNResult(gameInfo.result));
+		    T_(gameInfo.resultDetails), PGNResult(gameInfo.result));
 	}
     } else {
 	res[0] = NULLCHAR;
@@ -14482,7 +14804,7 @@ ParseFEN(board, blackPlaysFirst, fen)
      char *fen;
 {
     int i, j;
-    char *p;
+    char *p, c;
     int emptycount;
     ChessSquare piece;
 
@@ -14575,7 +14897,12 @@ ParseFEN(board, blackPlaysFirst, fen)
     while(*p == ' ') p++;
 
     /* Active color */
-    switch (*p++) {
+    c = *p++;
+    if(appData.colorNickNames) {
+      if( c == appData.colorNickNames[0] ) c = 'w'; else
+      if( c == appData.colorNickNames[1] ) c = 'b';
+    }
+    switch (c) {
       case 'w':
         *blackPlaysFirst = FALSE;
 	break;
@@ -14878,7 +15205,7 @@ PushTail(int firstMove, int lastMove)
 	}
 
 	storedGames++;
-	forwardMostMove = currentMove; // truncte game so we can start variation
+	forwardMostMove = firstMove; // truncate game so we can start variation
 	if(storedGames == 1) GreyRevert(FALSE);
 }
 
@@ -14890,6 +15217,7 @@ PopTail(Boolean annotate)
 
 	if(appData.icsActive) return FALSE; // only in local mode
 	if(!storedGames) return FALSE; // sanity
+	CommentPopDown(); // make sure no stale variation comments to the destroyed line can remain open
 
 	storedGames--;
 	ToNrEvent(savedFirst[storedGames]); // sets currentMove
@@ -14903,11 +15231,12 @@ PopTail(Boolean annotate)
 			     sprintf(moveBuf, " %d. %s", i+2>>1, SavePart(parseList[i]));
 			else sprintf(moveBuf, " %s", SavePart(parseList[i]));
 			strcat(buf, moveBuf);
+			if(commentList[i]) { strcat(buf, " "); strcat(buf, commentList[i]); }
 			if(!--cnt) { strcat(buf, "\n"); cnt = 10; }
 		}
 		strcat(buf, ")");
 	}
-	for(i=1; i<nrMoves; i++) { // copy last variation back
+	for(i=1; i<=nrMoves; i++) { // copy last variation back
 	    CopyBoard(boards[currentMove+i], boards[framePtr+i]);
 	    for(j=0; j<MOVE_LEN; j++)
 		moveList[currentMove+i-1][j] = moveList[framePtr+i][j];
@@ -14948,3 +15277,36 @@ CleanupTail()
 	framePtr = MAX_MOVES-1;
 	storedGames = 0;
 }
+
+void
+LoadVariation(int index, char *text)
+{       // [HGM] vari: shelve previous line and load new variation, parsed from text around text[index]
+	char *p = text, *start = NULL, *end = NULL, wait = NULLCHAR;
+	int level = 0, move;
+
+	if(gameMode != EditGame && gameMode != AnalyzeMode) 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 ]}
+		if(*p == '{') wait = '}'; else
+		if(*p == '[') wait = ']'; else
+		if(*p == '(' && level++ == 0 && p-text < index) start = p+1;
+		if(*p == ')' && level > 0 && --level == 0 && p-text > index && end == NULL) end = p-1;
+	    }
+	    if(*p == wait) wait = NULLCHAR; // closing ]} found
+	    p++;
+	}
+	if(!start || !end) return; // no variation found, or syntax error in PGN: ignore click
+	if(appData.debugMode) fprintf(debugFP, "at move %d load variation '%s'\n", currentMove, start);
+	end[1] = NULLCHAR; // clip off comment beyond variation
+	ToNrEvent(currentMove-1);
+	PushTail(currentMove, forwardMostMove); // shelve main variation. This truncates game
+	// kludge: use ParsePV() to append variation to game
+	move = currentMove;
+	ParsePV(start, TRUE);
+	forwardMostMove = endPV; endPV = -1; currentMove = move; // cleanup what ParsePV did
+	ClearPremoveHighlights();
+	CommentPopDown();
+	ToNrEvent(currentMove+1);
+}
+